Implemented the "aria-current" state on Windows.

content/browser/accessibility/browser_accessibility_win.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/accessibility/browser_accessibility_win.h"
 
 #include <UIAutomationClient.h>
 #include <UIAutomationCoreApi.h>
 
 #include <algorithm>
@@ skipping 3363 matching lines @@
   BoolAttributeToIA2(ui::AX_ATTR_CONTAINER_LIVE_BUSY,
                      "container-busy");
 
   // Expose the non-standard explicit-name IA2 attribute.
   int name_from;
   if (GetIntAttribute(ui::AX_ATTR_NAME_FROM, &name_from) &&
       name_from != ui::AX_NAME_FROM_CONTENTS) {
     win_attributes_->ia2_attributes.push_back(L"explicit-name:true");
   }
 
+  // Expose the aria-current attribute.
+  int32_t aria_current_state;
+  if (GetIntAttribute(ui::AX_ATTR_ARIA_CURRENT_STATE, &aria_current_state)) {
+    switch (static_cast<ui::AXAriaCurrentState>(aria_current_state)) {
+      case ui::AX_ARIA_CURRENT_STATE_NONE:
+        break;
+      case ui::AX_ARIA_CURRENT_STATE_FALSE:
+        win_attributes_->ia2_attributes.push_back(L"current:false");
+        break;
+      case ui::AX_ARIA_CURRENT_STATE_TRUE:
+        win_attributes_->ia2_attributes.push_back(L"current:true");
+        break;
+      case ui::AX_ARIA_CURRENT_STATE_PAGE:
+        win_attributes_->ia2_attributes.push_back(L"current:page");
+        break;
+      case ui::AX_ARIA_CURRENT_STATE_STEP:
+        win_attributes_->ia2_attributes.push_back(L"current:step");
+        break;
+      case ui::AX_ARIA_CURRENT_STATE_LOCATION:
+        win_attributes_->ia2_attributes.push_back(L"current:location");
+        break;
+      case ui::AX_ARIA_CURRENT_STATE_DATE:
+        win_attributes_->ia2_attributes.push_back(L"current:date");
+        break;
+      case ui::AX_ARIA_CURRENT_STATE_TIME:
+        win_attributes_->ia2_attributes.push_back(L"current:time");
+        break;
+    }
+  }
+
   // Expose table cell index.
   if (IsCellOrTableHeaderRole()) {
     BrowserAccessibility* table = GetParent();
     while (table && table->GetRole() != ui::AX_ROLE_TABLE)
       table = table->GetParent();
     if (table) {
       const std::vector<int32_t>& unique_cell_ids =
           table->GetIntListAttribute(ui::AX_ATTR_UNIQUE_CELL_IDS);
       for (size_t i = 0; i < unique_cell_ids.size(); ++i) {
         if (unique_cell_ids[i] == GetId()) {
           win_attributes_->ia2_attributes.push_back(
               base::string16(L"table-cell-index:") + base::IntToString16(i));
         }
       }
     }
   }
 
   // Expose row or column header sort direction.
   int32_t sort_direction;
   if ((ia_role() == ROLE_SYSTEM_COLUMNHEADER ||
       ia_role() == ROLE_SYSTEM_ROWHEADER) &&
       GetIntAttribute(ui::AX_ATTR_SORT_DIRECTION, &sort_direction)) {
-    switch (sort_direction) {
+    switch (static_cast<ui::AXSortDirection>(sort_direction)) {
+      case ui::AX_SORT_DIRECTION_NONE:
+        break;
       case ui::AX_SORT_DIRECTION_UNSORTED:
         win_attributes_->ia2_attributes.push_back(L"sort:none");
         break;
       case ui::AX_SORT_DIRECTION_ASCENDING:
         win_attributes_->ia2_attributes.push_back(L"sort:ascending");
         break;
       case ui::AX_SORT_DIRECTION_DESCENDING:
         win_attributes_->ia2_attributes.push_back(L"sort:descending");
         break;
       case ui::AX_SORT_DIRECTION_OTHER:
         win_attributes_->ia2_attributes.push_back(L"sort:other");
         break;
-      default:
-        NOTREACHED();
     }
   }
 
   win_attributes_->name = GetString16Attribute(ui::AX_ATTR_NAME);
   win_attributes_->description = GetString16Attribute(ui::AX_ATTR_DESCRIPTION);
 
   base::string16 value = GetValue();
 
   // On Windows, the value of a document should be its url.
   if (GetRole() == ui::AX_ROLE_ROOT_WEB_AREA ||
@@ skipping 302 matching lines @@
       if (GetString16Attribute(ui::AX_ATTR_ARIA_INVALID_VALUE,
                                &aria_invalid_value)) {
         SanitizeStringAttributeForIA2(aria_invalid_value, &aria_invalid_value);
         attributes.push_back(L"invalid:" + aria_invalid_value);
       } else {
         // Set the attribute to L"true", since we cannot be more specific.
         attributes.push_back(L"invalid:true");
       }
       break;
     }
-    default:
-      NOTREACHED();
   }
 
   base::string16 language(GetInheritedString16Attribute(ui::AX_ATTR_LANGUAGE));
   // Default value should be L"en-US".
   if (language.empty()) {
     attributes.push_back(L"language:en-US");
   } else {
     SanitizeStringAttributeForIA2(language, &language);
     attributes.push_back(L"language:" + language);
   }
@@ skipping 24 matching lines @@
     case ui::AX_TEXT_DIRECTION_RTL:
       attributes.push_back(L"writing-mode:rl");
       break;
     case ui::AX_TEXT_DIRECTION_TTB:
       attributes.push_back(L"writing-mode:tb");
       break;
     case ui::AX_TEXT_DIRECTION_BTT:
       // Not listed in the IA2 Spec.
       attributes.push_back(L"writing-mode:bt");
       break;
-    default:
-      NOTREACHED();
   }
 
   return attributes;
 }
 
 BrowserAccessibilityWin* BrowserAccessibilityWin::NewReference() {
   AddRef();
   return this;
 }
 
@@ skipping 423 matching lines @@
     case IA2_TEXT_BOUNDARY_WORD:
       return ui::WORD_BOUNDARY;
     case IA2_TEXT_BOUNDARY_LINE:
       return ui::LINE_BOUNDARY;
     case IA2_TEXT_BOUNDARY_SENTENCE:
       return ui::SENTENCE_BOUNDARY;
     case IA2_TEXT_BOUNDARY_PARAGRAPH:
       return ui::PARAGRAPH_BOUNDARY;
     case IA2_TEXT_BOUNDARY_ALL:
       return ui::ALL_BOUNDARY;
-    default:
-      NOTREACHED();
   }
+  NOTREACHED();
   return ui::CHAR_BOUNDARY;
 }
 
 LONG BrowserAccessibilityWin::FindBoundary(
     const base::string16& text,
     IA2TextBoundaryType ia2_boundary,
     LONG start_offset,
     ui::TextBoundaryDirection direction) {
   HandleSpecialTextOffset(text, &start_offset);
   if (ia2_boundary == IA2_TEXT_BOUNDARY_WORD)
@@ skipping 24 matching lines @@
       --iterator;
       return static_cast<LONG>(iterator->first);
     }
     case ui::FORWARDS_DIRECTION: {
       const auto iterator =
           offset_to_text_attributes().upper_bound(start_offset);
       if (iterator == offset_to_text_attributes().end())
         return text_length;
       return static_cast<LONG>(iterator->first);
     }
-    default:
-      NOTREACHED();
   }
 
   return start_offset;
 }
 
 BrowserAccessibilityWin* BrowserAccessibilityWin::GetFromID(int32_t id) const {
   if (!instance_active())
     return nullptr;
   return ToBrowserAccessibilityWin(manager()->GetFromID(id));
 }
@@ skipping 670 matching lines @@
   return static_cast<BrowserAccessibilityWin*>(obj);
 }
 
 const BrowserAccessibilityWin*
 ToBrowserAccessibilityWin(const BrowserAccessibility* obj) {
   DCHECK(!obj || obj->IsNative());
   return static_cast<const BrowserAccessibilityWin*>(obj);
 }
 
 }  // namespace content