content/browser/accessibility/browser_accessibility_auralinux.cc

   1 // Copyright (c) 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/browser/accessibility/browser_accessibility_auralinux.h"
   6
   7 #include "base/strings/utf_string_conversions.h"
   8 #include "content/browser/accessibility/browser_accessibility_manager_auralinux.h"
   9 #include "content/common/accessibility_messages.h"
  10
  11 namespace content {
  12
  13 static gpointer browser_accessibility_parent_class = NULL;
  14
  15 static BrowserAccessibilityAuraLinux* ToBrowserAccessibilityAuraLinux(
  16     BrowserAccessibilityAtk* atk_object) {
  17   if (!atk_object)
  18     return NULL;
  19
  20   return atk_object->m_object;
  21 }
  22
  23 //
  24 // AtkAction interface.
  25 //
  26
  27 static BrowserAccessibilityAuraLinux* ToBrowserAccessibilityAuraLinux(
  28     AtkAction* atk_action) {
  29   if (!IS_BROWSER_ACCESSIBILITY(atk_action))
  30     return NULL;
  31
  32   return ToBrowserAccessibilityAuraLinux(BROWSER_ACCESSIBILITY(atk_action));
  33 }
  34
  35 static gboolean browser_accessibility_do_action(AtkAction* atk_action,
  36                                                 gint index) {
  37   g_return_val_if_fail(ATK_IS_ACTION(atk_action), FALSE);
  38   g_return_val_if_fail(!index, FALSE);
  39
  40   BrowserAccessibilityAuraLinux* obj =
  41       ToBrowserAccessibilityAuraLinux(atk_action);
  42   if (!obj)
  43     return FALSE;
  44
  45   obj->manager()->DoDefaultAction(*obj);
  46
  47   return TRUE;
  48 }
  49
  50 static gint browser_accessibility_get_n_actions(AtkAction* atk_action) {
  51   g_return_val_if_fail(ATK_IS_ACTION(atk_action), 0);
  52
  53   BrowserAccessibilityAuraLinux* obj =
  54       ToBrowserAccessibilityAuraLinux(atk_action);
  55   if (!obj)
  56     return 0;
  57
  58   return 1;
  59 }
  60
  61 static const gchar* browser_accessibility_get_description(AtkAction* atk_action,
  62                                                           gint) {
  63   g_return_val_if_fail(ATK_IS_ACTION(atk_action), 0);
  64   BrowserAccessibilityAuraLinux* obj =
  65       ToBrowserAccessibilityAuraLinux(atk_action);
  66   if (!obj)
  67     return 0;
  68
  69   return 0;
  70 }
  71
  72 static const gchar* browser_accessibility_get_name(AtkAction* atk_action,
  73                                                    gint index) {
  74   g_return_val_if_fail(ATK_IS_ACTION(atk_action), 0);
  75   g_return_val_if_fail(!index, 0);
  76   BrowserAccessibilityAuraLinux* obj =
  77       ToBrowserAccessibilityAuraLinux(atk_action);
  78   if (!obj)
  79     return 0;
  80
  81   return obj->GetStringAttribute(ui::AX_ATTR_ACTION).c_str();
  82 }
  83
  84 static const gchar* browser_accessibility_get_keybinding(AtkAction* atk_action,
  85                                                          gint index) {
  86   g_return_val_if_fail(ATK_IS_ACTION(atk_action), 0);
  87   g_return_val_if_fail(!index, 0);
  88   BrowserAccessibilityAuraLinux* obj =
  89       ToBrowserAccessibilityAuraLinux(atk_action);
  90   if (!obj)
  91     return 0;
  92
  93   return obj->GetStringAttribute(ui::AX_ATTR_ACCESS_KEY).c_str();
  94 }
  95
  96 static void ActionInterfaceInit(AtkActionIface* iface) {
  97   iface->do_action = browser_accessibility_do_action;
  98   iface->get_n_actions = browser_accessibility_get_n_actions;
  99   iface->get_description = browser_accessibility_get_description;
 100   iface->get_name = browser_accessibility_get_name;
 101   iface->get_keybinding = browser_accessibility_get_keybinding;
 102 }
 103
 104 static const GInterfaceInfo ActionInfo = {
 105     reinterpret_cast<GInterfaceInitFunc>(ActionInterfaceInit), 0, 0};
 106
 107 //
 108 // AtkComponent interface.
 109 //
 110
 111 static BrowserAccessibilityAuraLinux* ToBrowserAccessibilityAuraLinux(
 112     AtkComponent* atk_component) {
 113   if (!IS_BROWSER_ACCESSIBILITY(atk_component))
 114     return NULL;
 115
 116   return ToBrowserAccessibilityAuraLinux(BROWSER_ACCESSIBILITY(atk_component));
 117 }
 118
 119 static AtkObject* browser_accessibility_accessible_at_point(
 120     AtkComponent* atk_component,
 121     gint x,
 122     gint y,
 123     AtkCoordType coord_type) {
 124   g_return_val_if_fail(ATK_IS_COMPONENT(atk_component), 0);
 125
 126   BrowserAccessibilityAuraLinux* obj =
 127       ToBrowserAccessibilityAuraLinux(atk_component);
 128   if (!obj)
 129     return NULL;
 130
 131   gfx::Point point(x, y);
 132   if (!obj->GetGlobalBoundsRect().Contains(point))
 133     return NULL;
 134
 135   BrowserAccessibility* result = obj->BrowserAccessibilityForPoint(point);
 136   if (!result)
 137     return NULL;
 138
 139   AtkObject* atk_result =
 140       result->ToBrowserAccessibilityAuraLinux()->GetAtkObject();
 141   g_object_ref(atk_result);
 142   return atk_result;
 143 }
 144
 145 static void browser_accessibility_get_extents(AtkComponent* atk_component,
 146                                               gint* x,
 147                                               gint* y,
 148                                               gint* width,
 149                                               gint* height,
 150                                               AtkCoordType coord_type) {
 151   g_return_if_fail(ATK_IS_COMPONENT(atk_component));
 152
 153   BrowserAccessibilityAuraLinux* obj =
 154       ToBrowserAccessibilityAuraLinux(atk_component);
 155   if (!obj)
 156     return;
 157
 158   gfx::Rect bounds = obj->GetGlobalBoundsRect();
 159   if (x)
 160     *x = bounds.x();
 161   if (y)
 162     *y = bounds.y();
 163   if (width)
 164     *width = bounds.width();
 165   if (height)
 166     *height = bounds.height();
 167 }
 168
 169 static gboolean browser_accessibility_grab_focus(AtkComponent* atk_component) {
 170   g_return_val_if_fail(ATK_IS_COMPONENT(atk_component), FALSE);
 171
 172   BrowserAccessibilityAuraLinux* obj =
 173       ToBrowserAccessibilityAuraLinux(atk_component);
 174   if (!obj)
 175     return false;
 176
 177   obj->manager()->SetFocus(obj, true);
 178   return true;
 179 }
 180
 181 static void ComponentInterfaceInit(AtkComponentIface* iface) {
 182   iface->ref_accessible_at_point = browser_accessibility_accessible_at_point;
 183   iface->get_extents = browser_accessibility_get_extents;
 184   iface->grab_focus = browser_accessibility_grab_focus;
 185 }
 186
 187 static const GInterfaceInfo ComponentInfo = {
 188     reinterpret_cast<GInterfaceInitFunc>(ComponentInterfaceInit),
 189     0,
 190     0};
 191
 192 //
 193 // AtkDocument interface.
 194 //
 195
 196 static BrowserAccessibilityAuraLinux* ToBrowserAccessibilityAuraLinux(
 197     AtkDocument* atk_doc) {
 198   if (!IS_BROWSER_ACCESSIBILITY(atk_doc))
 199     return NULL;
 200
 201   return ToBrowserAccessibilityAuraLinux(BROWSER_ACCESSIBILITY(atk_doc));
 202 }
 203
 204 static const gchar* GetDocumentAttributeValue(
 205     BrowserAccessibilityAuraLinux* obj,
 206     const gchar* attribute) {
 207   if (!g_ascii_strcasecmp(attribute, "DocType"))
 208     return obj->GetStringAttribute(ui::AX_ATTR_DOC_DOCTYPE).c_str();
 209   else if (!g_ascii_strcasecmp(attribute, "MimeType"))
 210     return obj->GetStringAttribute(ui::AX_ATTR_DOC_MIMETYPE).c_str();
 211   else if (!g_ascii_strcasecmp(attribute, "Title"))
 212     return obj->GetStringAttribute(ui::AX_ATTR_DOC_TITLE).c_str();
 213   else if (!g_ascii_strcasecmp(attribute, "URI"))
 214     return obj->GetStringAttribute(ui::AX_ATTR_DOC_URL).c_str();
 215
 216   return 0;
 217 }
 218
 219 AtkAttributeSet* SetAtkAttributeSet(AtkAttributeSet* attribute_set,
 220                                     const char* name,
 221                                     const char* value) {
 222   AtkAttribute* attribute =
 223       static_cast<AtkAttribute*>(g_malloc(sizeof(AtkAttribute)));
 224   attribute->name = g_strdup(name);
 225   attribute->value = g_strdup(value);
 226   attribute_set = g_slist_prepend(attribute_set, attribute);
 227   return attribute_set;
 228 }
 229
 230 static const gchar* browser_accessibility_get_attribute_value(
 231     AtkDocument* atk_doc,
 232     const gchar* attribute) {
 233   g_return_val_if_fail(ATK_IS_DOCUMENT(atk_doc), 0);
 234   BrowserAccessibilityAuraLinux* obj = ToBrowserAccessibilityAuraLinux(atk_doc);
 235   if (!obj)
 236     return 0;
 237
 238   return GetDocumentAttributeValue(obj, attribute);
 239 }
 240
 241 static AtkAttributeSet* browser_accessibility_get_attributes(
 242     AtkDocument* atk_doc) {
 243   g_return_val_if_fail(ATK_IS_DOCUMENT(atk_doc), 0);
 244   BrowserAccessibilityAuraLinux* obj = ToBrowserAccessibilityAuraLinux(atk_doc);
 245   if (!obj)
 246     return 0;
 247
 248   AtkAttributeSet* attribute_set = 0;
 249   const gchar* doc_attributes[] = {"DocType", "MimeType", "Title", "URI"};
 250   const gchar* value = 0;
 251
 252   for (unsigned i = 0; i < G_N_ELEMENTS(doc_attributes); i++) {
 253     value = GetDocumentAttributeValue(obj, doc_attributes[i]);
 254     if (value)
 255       attribute_set =
 256           SetAtkAttributeSet(attribute_set, doc_attributes[i], value);
 257   }
 258
 259   return attribute_set;
 260 }
 261
 262 static void DocumentInterfaceInit(AtkDocumentIface* iface) {
 263   iface->get_document_attribute_value =
 264       browser_accessibility_get_attribute_value;
 265   iface->get_document_attributes = browser_accessibility_get_attributes;
 266 }
 267
 268 static const GInterfaceInfo DocumentInfo = {
 269     reinterpret_cast<GInterfaceInitFunc>(DocumentInterfaceInit), 0, 0};
 270
 271 //
 272 // AtkValue interface.
 273 //
 274
 275 static BrowserAccessibilityAuraLinux* ToBrowserAccessibilityAuraLinux(
 276     AtkValue* atk_object) {
 277   if (!IS_BROWSER_ACCESSIBILITY(atk_object))
 278     return NULL;
 279
 280   return ToBrowserAccessibilityAuraLinux(BROWSER_ACCESSIBILITY(atk_object));
 281 }
 282
 283 static float GetStepAttribute(BrowserAccessibilityAuraLinux* obj) {
 284   // TODO(shreeram.k): Get Correct value of Step attribute.
 285   return 1.0;
 286 }
 287
 288 static void browser_accessibility_get_current_value(AtkValue* atk_value,
 289                                                     GValue* value) {
 290   g_return_if_fail(ATK_VALUE(atk_value));
 291
 292   BrowserAccessibilityAuraLinux* obj =
 293       ToBrowserAccessibilityAuraLinux(atk_value);
 294   if (!obj)
 295     return;
 296
 297   float float_val;
 298   if (obj->GetFloatAttribute(ui::AX_ATTR_VALUE_FOR_RANGE, &float_val)) {
 299     memset(value, 0, sizeof(*value));
 300     g_value_init(value, G_TYPE_FLOAT);
 301     g_value_set_float(value, float_val);
 302   }
 303 }
 304
 305 static void browser_accessibility_get_minimum_value(AtkValue* atk_value,
 306                                                     GValue* value) {
 307   g_return_if_fail(ATK_VALUE(atk_value));
 308
 309   BrowserAccessibilityAuraLinux* obj =
 310       ToBrowserAccessibilityAuraLinux(atk_value);
 311   if (!obj)
 312     return;
 313
 314   float float_val;
 315   if (obj->GetFloatAttribute(ui::AX_ATTR_MIN_VALUE_FOR_RANGE, &float_val)) {
 316     memset(value, 0, sizeof(*value));
 317     g_value_init(value, G_TYPE_FLOAT);
 318     g_value_set_float(value, float_val);
 319   }
 320 }
 321
 322 static void browser_accessibility_get_maximum_value(AtkValue* atk_value,
 323                                                     GValue* value) {
 324   g_return_if_fail(ATK_VALUE(atk_value));
 325
 326   BrowserAccessibilityAuraLinux* obj =
 327       ToBrowserAccessibilityAuraLinux(atk_value);
 328   if (!obj)
 329     return;
 330
 331   float float_val;
 332   if (obj->GetFloatAttribute(ui::AX_ATTR_MAX_VALUE_FOR_RANGE, &float_val)) {
 333     memset(value, 0, sizeof(*value));
 334     g_value_init(value, G_TYPE_FLOAT);
 335     g_value_set_float(value, float_val);
 336   }
 337 }
 338
 339 static void browser_accessibility_get_minimum_increment(AtkValue* atk_value,
 340                                                         GValue* gValue) {
 341   g_return_if_fail(ATK_VALUE(atk_value));
 342
 343   memset(gValue, 0, sizeof(GValue));
 344   g_value_init(gValue, G_TYPE_FLOAT);
 345
 346   BrowserAccessibilityAuraLinux* obj =
 347       ToBrowserAccessibilityAuraLinux(atk_value);
 348   if (!obj)
 349     return;
 350
 351   g_value_set_float(gValue, GetStepAttribute(obj));
 352 }
 353
 354 static void ValueInterfaceInit(AtkValueIface* iface) {
 355   iface->get_current_value = browser_accessibility_get_current_value;
 356   iface->get_minimum_value = browser_accessibility_get_minimum_value;
 357   iface->get_maximum_value = browser_accessibility_get_maximum_value;
 358   iface->get_minimum_increment = browser_accessibility_get_minimum_increment;
 359 }
 360
 361 static const GInterfaceInfo ValueInfo = {
 362     reinterpret_cast<GInterfaceInitFunc>(ValueInterfaceInit),
 363     0,
 364     0};
 365
 366 //
 367 // AtkObject interface
 368 //
 369
 370 static BrowserAccessibilityAuraLinux* ToBrowserAccessibilityAuraLinux(
 371     AtkObject* atk_object) {
 372   if (!IS_BROWSER_ACCESSIBILITY(atk_object))
 373     return NULL;
 374
 375   return ToBrowserAccessibilityAuraLinux(BROWSER_ACCESSIBILITY(atk_object));
 376 }
 377
 378 static const gchar* browser_accessibility_get_name(AtkObject* atk_object) {
 379   BrowserAccessibilityAuraLinux* obj =
 380       ToBrowserAccessibilityAuraLinux(atk_object);
 381   if (!obj)
 382     return NULL;
 383
 384   return obj->GetStringAttribute(ui::AX_ATTR_NAME).c_str();
 385 }
 386
 387 static const gchar* browser_accessibility_get_description(
 388     AtkObject* atk_object) {
 389   BrowserAccessibilityAuraLinux* obj =
 390       ToBrowserAccessibilityAuraLinux(atk_object);
 391   if (!obj)
 392     return NULL;
 393
 394   return obj->GetStringAttribute(ui::AX_ATTR_DESCRIPTION).c_str();
 395 }
 396
 397 static AtkObject* browser_accessibility_get_parent(AtkObject* atk_object) {
 398   BrowserAccessibilityAuraLinux* obj =
 399       ToBrowserAccessibilityAuraLinux(atk_object);
 400   if (!obj)
 401     return NULL;
 402   if (obj->GetParent())
 403     return obj->GetParent()->ToBrowserAccessibilityAuraLinux()->GetAtkObject();
 404
 405   BrowserAccessibilityManagerAuraLinux* manager =
 406       static_cast<BrowserAccessibilityManagerAuraLinux*>(obj->manager());
 407   return manager->parent_object();
 408 }
 409
 410 static gint browser_accessibility_get_n_children(AtkObject* atk_object) {
 411   BrowserAccessibilityAuraLinux* obj =
 412       ToBrowserAccessibilityAuraLinux(atk_object);
 413   if (!obj)
 414     return 0;
 415
 416   return obj->PlatformChildCount();
 417 }
 418
 419 static AtkObject* browser_accessibility_ref_child(AtkObject* atk_object,
 420                                                   gint index) {
 421   BrowserAccessibilityAuraLinux* obj =
 422       ToBrowserAccessibilityAuraLinux(atk_object);
 423   if (!obj)
 424     return NULL;
 425
 426   if (index < 0 || index >= static_cast<gint>(obj->PlatformChildCount()))
 427     return NULL;
 428
 429   AtkObject* result = obj->InternalGetChild(index)
 430                           ->ToBrowserAccessibilityAuraLinux()
 431                           ->GetAtkObject();
 432   g_object_ref(result);
 433   return result;
 434 }
 435
 436 static gint browser_accessibility_get_index_in_parent(AtkObject* atk_object) {
 437   BrowserAccessibilityAuraLinux* obj =
 438       ToBrowserAccessibilityAuraLinux(atk_object);
 439   if (!obj)
 440     return 0;
 441   return obj->GetIndexInParent();
 442 }
 443
 444 static AtkAttributeSet* browser_accessibility_get_attributes(
 445     AtkObject* atk_object) {
 446   return NULL;
 447 }
 448
 449 static AtkRole browser_accessibility_get_role(AtkObject* atk_object) {
 450   BrowserAccessibilityAuraLinux* obj =
 451       ToBrowserAccessibilityAuraLinux(atk_object);
 452   if (!obj)
 453     return ATK_ROLE_INVALID;
 454   return obj->atk_role();
 455 }
 456
 457 static AtkStateSet* browser_accessibility_ref_state_set(AtkObject* atk_object) {
 458   BrowserAccessibilityAuraLinux* obj =
 459       ToBrowserAccessibilityAuraLinux(atk_object);
 460   if (!obj)
 461     return NULL;
 462   AtkStateSet* state_set = ATK_OBJECT_CLASS(browser_accessibility_parent_class)
 463                                ->ref_state_set(atk_object);
 464   int32 state = obj->GetState();
 465
 466   if (state & (1 << ui::AX_STATE_FOCUSABLE))
 467     atk_state_set_add_state(state_set, ATK_STATE_FOCUSABLE);
 468   if (obj->manager()->GetFocus(NULL) == obj)
 469     atk_state_set_add_state(state_set, ATK_STATE_FOCUSED);
 470   if (state & (1 << ui::AX_STATE_ENABLED))
 471     atk_state_set_add_state(state_set, ATK_STATE_ENABLED);
 472
 473   return state_set;
 474 }
 475
 476 static AtkRelationSet* browser_accessibility_ref_relation_set(
 477     AtkObject* atk_object) {
 478   AtkRelationSet* relation_set =
 479       ATK_OBJECT_CLASS(browser_accessibility_parent_class)
 480           ->ref_relation_set(atk_object);
 481   return relation_set;
 482 }
 483
 484 //
 485 // The rest of the BrowserAccessibilityAuraLinux code, not specific to one
 486 // of the Atk* interfaces.
 487 //
 488
 489 static void browser_accessibility_init(AtkObject* atk_object, gpointer data) {
 490   if (ATK_OBJECT_CLASS(browser_accessibility_parent_class)->initialize) {
 491     ATK_OBJECT_CLASS(browser_accessibility_parent_class)
 492         ->initialize(atk_object, data);
 493   }
 494
 495   BROWSER_ACCESSIBILITY(atk_object)->m_object =
 496       reinterpret_cast<BrowserAccessibilityAuraLinux*>(data);
 497 }
 498
 499 static void browser_accessibility_finalize(GObject* atk_object) {
 500   G_OBJECT_CLASS(browser_accessibility_parent_class)->finalize(atk_object);
 501 }
 502
 503 static void browser_accessibility_class_init(AtkObjectClass* klass) {
 504   GObjectClass* gobject_class = G_OBJECT_CLASS(klass);
 505   browser_accessibility_parent_class = g_type_class_peek_parent(klass);
 506
 507   gobject_class->finalize = browser_accessibility_finalize;
 508   klass->initialize = browser_accessibility_init;
 509   klass->get_name = browser_accessibility_get_name;
 510   klass->get_description = browser_accessibility_get_description;
 511   klass->get_parent = browser_accessibility_get_parent;
 512   klass->get_n_children = browser_accessibility_get_n_children;
 513   klass->ref_child = browser_accessibility_ref_child;
 514   klass->get_role = browser_accessibility_get_role;
 515   klass->ref_state_set = browser_accessibility_ref_state_set;
 516   klass->get_index_in_parent = browser_accessibility_get_index_in_parent;
 517   klass->get_attributes = browser_accessibility_get_attributes;
 518   klass->ref_relation_set = browser_accessibility_ref_relation_set;
 519 }
 520
 521 GType browser_accessibility_get_type() {
 522   static volatile gsize type_volatile = 0;
 523
 524 #if !GLIB_CHECK_VERSION(2, 36, 0)
 525   g_type_init();
 526 #endif
 527
 528   if (g_once_init_enter(&type_volatile)) {
 529     static const GTypeInfo tinfo = {
 530         sizeof(BrowserAccessibilityAtkClass),
 531         (GBaseInitFunc)0,
 532         (GBaseFinalizeFunc)0,
 533         (GClassInitFunc)browser_accessibility_class_init,
 534         (GClassFinalizeFunc)0,
 535         0,                               /* class data */
 536         sizeof(BrowserAccessibilityAtk), /* instance size */
 537         0,                               /* nb preallocs */
 538         (GInstanceInitFunc)0,
 539         0 /* value table */
 540     };
 541
 542     GType type = g_type_register_static(ATK_TYPE_OBJECT, "BrowserAccessibility",
 543                                         &tinfo, GTypeFlags(0));
 544     g_once_init_leave(&type_volatile, type);
 545   }
 546
 547   return type_volatile;
 548 }
 549
 550 static const char* GetUniqueAccessibilityTypeName(int interface_mask) {
 551   // 20 characters is enough for "Chrome%x" with any integer value.
 552   static char name[20];
 553   snprintf(name, sizeof(name), "Chrome%x", interface_mask);
 554   return name;
 555 }
 556
 557 enum AtkInterfaces {
 558   ATK_ACTION_INTERFACE,
 559   ATK_COMPONENT_INTERFACE,
 560   ATK_DOCUMENT_INTERFACE,
 561   ATK_EDITABLE_TEXT_INTERFACE,
 562   ATK_HYPERLINK_INTERFACE,
 563   ATK_HYPERTEXT_INTERFACE,
 564   ATK_IMAGE_INTERFACE,
 565   ATK_SELECTION_INTERFACE,
 566   ATK_TABLE_INTERFACE,
 567   ATK_TEXT_INTERFACE,
 568   ATK_VALUE_INTERFACE,
 569 };
 570
 571 static int GetInterfaceMaskFromObject(BrowserAccessibilityAuraLinux* obj) {
 572   int interface_mask = 0;
 573
 574   // Component interface is always supported.
 575   interface_mask |= 1 << ATK_COMPONENT_INTERFACE;
 576
 577   // Action interface is basic one. It just relays on executing default action
 578   // for each object.
 579   interface_mask |= 1 << ATK_ACTION_INTERFACE;
 580
 581   // Value Interface
 582   int role = obj->GetRole();
 583   if (role == ui::AX_ROLE_PROGRESS_INDICATOR ||
 584       role == ui::AX_ROLE_SCROLL_BAR || role == ui::AX_ROLE_SLIDER) {
 585     interface_mask |= 1 << ATK_VALUE_INTERFACE;
 586   }
 587
 588   // Document Interface
 589   if (role == ui::AX_ROLE_DOCUMENT || role == ui::AX_ROLE_ROOT_WEB_AREA ||
 590       role == ui::AX_ROLE_WEB_AREA)
 591     interface_mask |= 1 << ATK_DOCUMENT_INTERFACE;
 592
 593   return interface_mask;
 594 }
 595
 596 static GType GetAccessibilityTypeFromObject(
 597     BrowserAccessibilityAuraLinux* obj) {
 598   static const GTypeInfo type_info = {
 599       sizeof(BrowserAccessibilityAtkClass),
 600       (GBaseInitFunc)0,
 601       (GBaseFinalizeFunc)0,
 602       (GClassInitFunc)0,
 603       (GClassFinalizeFunc)0,
 604       0,                               /* class data */
 605       sizeof(BrowserAccessibilityAtk), /* instance size */
 606       0,                               /* nb preallocs */
 607       (GInstanceInitFunc)0,
 608       0 /* value table */
 609   };
 610
 611   int interface_mask = GetInterfaceMaskFromObject(obj);
 612   const char* atk_type_name = GetUniqueAccessibilityTypeName(interface_mask);
 613   GType type = g_type_from_name(atk_type_name);
 614   if (type)
 615     return type;
 616
 617   type = g_type_register_static(BROWSER_ACCESSIBILITY_TYPE, atk_type_name,
 618                                 &type_info, GTypeFlags(0));
 619   if (interface_mask & (1 << ATK_ACTION_INTERFACE))
 620     g_type_add_interface_static(type, ATK_TYPE_ACTION, &ActionInfo);
 621   if (interface_mask & (1 << ATK_COMPONENT_INTERFACE))
 622     g_type_add_interface_static(type, ATK_TYPE_COMPONENT, &ComponentInfo);
 623   if (interface_mask & (1 << ATK_DOCUMENT_INTERFACE))
 624     g_type_add_interface_static(type, ATK_TYPE_DOCUMENT, &DocumentInfo);
 625   if (interface_mask & (1 << ATK_VALUE_INTERFACE))
 626     g_type_add_interface_static(type, ATK_TYPE_VALUE, &ValueInfo);
 627
 628   return type;
 629 }
 630
 631 BrowserAccessibilityAtk* browser_accessibility_new(
 632     BrowserAccessibilityAuraLinux* obj) {
 633   GType type = GetAccessibilityTypeFromObject(obj);
 634   AtkObject* atk_object = static_cast<AtkObject*>(g_object_new(type, 0));
 635
 636   atk_object_initialize(atk_object, obj);
 637
 638   return BROWSER_ACCESSIBILITY(atk_object);
 639 }
 640
 641 void browser_accessibility_detach(BrowserAccessibilityAtk* atk_object) {
 642   atk_object->m_object = NULL;
 643 }
 644
 645 // static
 646 BrowserAccessibility* BrowserAccessibility::Create() {
 647   return new BrowserAccessibilityAuraLinux();
 648 }
 649
 650 BrowserAccessibilityAuraLinux*
 651 BrowserAccessibility::ToBrowserAccessibilityAuraLinux() {
 652   return static_cast<BrowserAccessibilityAuraLinux*>(this);
 653 }
 654
 655 BrowserAccessibilityAuraLinux::BrowserAccessibilityAuraLinux()
 656     : atk_object_(NULL) {
 657 }
 658
 659 BrowserAccessibilityAuraLinux::~BrowserAccessibilityAuraLinux() {
 660   browser_accessibility_detach(BROWSER_ACCESSIBILITY(atk_object_));
 661   if (atk_object_)
 662     g_object_unref(atk_object_);
 663 }
 664
 665 AtkObject* BrowserAccessibilityAuraLinux::GetAtkObject() const {
 666   if (!G_IS_OBJECT(atk_object_))
 667     return NULL;
 668   return atk_object_;
 669 }
 670
 671 void BrowserAccessibilityAuraLinux::OnDataChanged() {
 672   BrowserAccessibility::OnDataChanged();
 673   InitRoleAndState();
 674
 675   if (atk_object_) {
 676     // If the object's role changes and that causes its
 677     // interface mask to change, we need to create a new
 678     // AtkObject for it.
 679     int interface_mask = GetInterfaceMaskFromObject(this);
 680     if (interface_mask != interface_mask_) {
 681       g_object_unref(atk_object_);
 682       atk_object_ = NULL;
 683     }
 684   }
 685
 686   if (!atk_object_) {
 687     interface_mask_ = GetInterfaceMaskFromObject(this);
 688     atk_object_ = ATK_OBJECT(browser_accessibility_new(this));
 689     if (this->GetParent()) {
 690       atk_object_set_parent(
 691           atk_object_,
 692           this->GetParent()->ToBrowserAccessibilityAuraLinux()->GetAtkObject());
 693     }
 694   }
 695 }
 696
 697 bool BrowserAccessibilityAuraLinux::IsNative() const {
 698   return true;
 699 }
 700
 701 void BrowserAccessibilityAuraLinux::InitRoleAndState() {
 702   switch (GetRole()) {
 703     case ui::AX_ROLE_DOCUMENT:
 704     case ui::AX_ROLE_ROOT_WEB_AREA:
 705     case ui::AX_ROLE_WEB_AREA:
 706       atk_role_ = ATK_ROLE_DOCUMENT_WEB;
 707       break;
 708     case ui::AX_ROLE_ALERT:
 709     case ui::AX_ROLE_ALERT_DIALOG:
 710       atk_role_ = ATK_ROLE_ALERT;
 711       break;
 712     case ui::AX_ROLE_APPLICATION:
 713       atk_role_ = ATK_ROLE_APPLICATION;
 714       break;
 715     case ui::AX_ROLE_BUTTON:
 716       atk_role_ = ATK_ROLE_PUSH_BUTTON;
 717       break;
 718     case ui::AX_ROLE_CANVAS:
 719       atk_role_ = ATK_ROLE_CANVAS;
 720       break;
 721     case ui::AX_ROLE_CAPTION:
 722       atk_role_ = ATK_ROLE_CAPTION;
 723       break;
 724     case ui::AX_ROLE_CHECK_BOX:
 725       atk_role_ = ATK_ROLE_CHECK_BOX;
 726       break;
 727     case ui::AX_ROLE_COLOR_WELL:
 728       atk_role_ = ATK_ROLE_COLOR_CHOOSER;
 729       break;
 730     case ui::AX_ROLE_COLUMN_HEADER:
 731       atk_role_ = ATK_ROLE_COLUMN_HEADER;
 732       break;
 733     case ui::AX_ROLE_COMBO_BOX:
 734       atk_role_ = ATK_ROLE_COMBO_BOX;
 735       break;
 736     case ui::AX_ROLE_DATE:
 737     case ui::AX_ROLE_DATE_TIME:
 738       atk_role_ = ATK_ROLE_DATE_EDITOR;
 739       break;
 740     case ui::AX_ROLE_DIALOG:
 741       atk_role_ = ATK_ROLE_DIALOG;
 742       break;
 743     case ui::AX_ROLE_DIV:
 744     case ui::AX_ROLE_GROUP:
 745       atk_role_ = ATK_ROLE_SECTION;
 746       break;
 747     case ui::AX_ROLE_FORM:
 748       atk_role_ = ATK_ROLE_FORM;
 749       break;
 750     case ui::AX_ROLE_IMAGE:
 751       atk_role_ = ATK_ROLE_IMAGE;
 752       break;
 753     case ui::AX_ROLE_IMAGE_MAP:
 754       atk_role_ = ATK_ROLE_IMAGE_MAP;
 755       break;
 756     case ui::AX_ROLE_LABEL_TEXT:
 757       atk_role_ = ATK_ROLE_LABEL;
 758       break;
 759     case ui::AX_ROLE_LINK:
 760       atk_role_ = ATK_ROLE_LINK;
 761       break;
 762     case ui::AX_ROLE_LIST:
 763       atk_role_ = ATK_ROLE_LIST;
 764       break;
 765     case ui::AX_ROLE_LIST_BOX:
 766       atk_role_ = ATK_ROLE_LIST_BOX;
 767       break;
 768     case ui::AX_ROLE_LIST_ITEM:
 769       atk_role_ = ATK_ROLE_LIST_ITEM;
 770       break;
 771     case ui::AX_ROLE_MENU:
 772       atk_role_ = ATK_ROLE_MENU;
 773       break;
 774     case ui::AX_ROLE_MENU_BAR:
 775       atk_role_ = ATK_ROLE_MENU_BAR;
 776       break;
 777     case ui::AX_ROLE_MENU_ITEM:
 778       atk_role_ = ATK_ROLE_MENU_ITEM;
 779       break;
 780     case ui::AX_ROLE_MENU_ITEM_CHECK_BOX:
 781       atk_role_ = ATK_ROLE_CHECK_MENU_ITEM;
 782       break;
 783     case ui::AX_ROLE_MENU_ITEM_RADIO:
 784       atk_role_ = ATK_ROLE_RADIO_MENU_ITEM;
 785       break;
 786     case ui::AX_ROLE_METER:
 787       atk_role_ = ATK_ROLE_PROGRESS_BAR;
 788       break;
 789     case ui::AX_ROLE_PARAGRAPH:
 790       atk_role_ = ATK_ROLE_PARAGRAPH;
 791       break;
 792     case ui::AX_ROLE_RADIO_BUTTON:
 793       atk_role_ = ATK_ROLE_RADIO_BUTTON;
 794       break;
 795     case ui::AX_ROLE_ROW_HEADER:
 796       atk_role_ = ATK_ROLE_ROW_HEADER;
 797       break;
 798     case ui::AX_ROLE_SCROLL_BAR:
 799       atk_role_ = ATK_ROLE_SCROLL_BAR;
 800       break;
 801     case ui::AX_ROLE_SLIDER:
 802       atk_role_ = ATK_ROLE_SLIDER;
 803       break;
 804     case ui::AX_ROLE_SPIN_BUTTON:
 805       atk_role_ = ATK_ROLE_SPIN_BUTTON;
 806       break;
 807     case ui::AX_ROLE_SPLITTER:
 808       atk_role_ = ATK_ROLE_SEPARATOR;
 809       break;
 810     case ui::AX_ROLE_STATIC_TEXT:
 811       atk_role_ = ATK_ROLE_TEXT;
 812       break;
 813     case ui::AX_ROLE_STATUS:
 814       atk_role_ = ATK_ROLE_STATUSBAR;
 815       break;
 816     case ui::AX_ROLE_TAB:
 817       atk_role_ = ATK_ROLE_PAGE_TAB;
 818       break;
 819     case ui::AX_ROLE_TABLE:
 820       atk_role_ = ATK_ROLE_TABLE;
 821       break;
 822     case ui::AX_ROLE_TAB_LIST:
 823       atk_role_ = ATK_ROLE_PAGE_TAB_LIST;
 824       break;
 825     case ui::AX_ROLE_TOGGLE_BUTTON:
 826       atk_role_ = ATK_ROLE_TOGGLE_BUTTON;
 827       break;
 828     case ui::AX_ROLE_TOOLBAR:
 829       atk_role_ = ATK_ROLE_TOOL_BAR;
 830       break;
 831     case ui::AX_ROLE_TOOLTIP:
 832       atk_role_ = ATK_ROLE_TOOL_TIP;
 833       break;
 834     case ui::AX_ROLE_TEXT_FIELD:
 835       atk_role_ = ATK_ROLE_ENTRY;
 836       break;
 837     case ui::AX_ROLE_TREE:
 838       atk_role_ = ATK_ROLE_TREE;
 839       break;
 840     case ui::AX_ROLE_TREE_ITEM:
 841       atk_role_ = ATK_ROLE_TREE_ITEM;
 842       break;
 843     default:
 844       atk_role_ = ATK_ROLE_UNKNOWN;
 845       break;
 846   }
 847 }
 848
 849 }  // namespace content