Implemented the reporting of text style and language information 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 101 matching lines @@
 
 STDMETHODIMP BrowserAccessibilityRelation::get_nTargets(long* n_targets) {
   if (!n_targets)
     return E_INVALIDARG;
 
   if (!owner_->instance_active())
     return E_FAIL;
 
   *n_targets = static_cast<long>(target_ids_.size());
 
-  BrowserAccessibilityManager* manager = owner_->manager();
   for (long i = *n_targets - 1; i >= 0; --i) {
-    BrowserAccessibility* result = manager->GetFromID(target_ids_[i]);
+    BrowserAccessibilityWin* result = owner_->GetFromID(target_ids_[i]);
     if (!result || !result->instance_active()) {
       *n_targets = 0;
       break;
     }
   }
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityRelation::get_target(long target_index,
                                                       IUnknown** target) {
   if (!target)
     return E_INVALIDARG;
 
   if (!owner_->instance_active())
     return E_FAIL;
 
   if (target_index < 0 ||
       target_index >= static_cast<long>(target_ids_.size())) {
     return E_INVALIDARG;
   }
 
-  BrowserAccessibilityManager* manager = owner_->manager();
-  BrowserAccessibility* result =
-      manager->GetFromID(target_ids_[target_index]);
+  BrowserAccessibility* result = owner_->GetFromID(target_ids_[target_index]);
   if (!result || !result->instance_active())
     return E_FAIL;
 
   *target = static_cast<IAccessible*>(
       result->ToBrowserAccessibilityWin()->NewReference());
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityRelation::get_targets(long max_targets,
                                                        IUnknown** targets,
@@ skipping 433 matching lines @@
       target->ia_role() == ROLE_SYSTEM_SCROLLBAR ||
       target->ia_role() == ROLE_SYSTEM_SLIDER) {
     base::string16 value_text = target->GetValueText();
     *value = SysAllocString(value_text.c_str());
     DCHECK(*value);
     return S_OK;
   }
 
   // Expose color well value.
   if (target->ia2_role() == IA2_ROLE_COLOR_CHOOSER) {
-    int color = target->GetIntAttribute(ui::AX_ATTR_COLOR_VALUE);
-    int red = (color >> 16) & 0xFF;
-    int green = (color >> 8) & 0xFF;
-    int blue = color & 0xFF;
+    unsigned int color = static_cast<unsigned int>(
+        target->GetIntAttribute(ui::AX_ATTR_COLOR_VALUE));
+    unsigned int red, green, blue, alpha;
+    RGBAToColorValues(color, &red, &green, &blue, &alpha);
     base::string16 value_text;
-    value_text = base::IntToString16((red * 100) / 255) + L"% red " +
-                 base::IntToString16((green * 100) / 255) + L"% green " +
-                 base::IntToString16((blue * 100) / 255) + L"% blue";
+    value_text = base::UintToString16(red * 100 / 255) + L"% red " +
+                 base::UintToString16(green * 100 / 255) + L"% green " +
+                 base::UintToString16(blue * 100 / 255) + L"% blue";
     *value = SysAllocString(value_text.c_str());
     DCHECK(*value);
     return S_OK;
   }
 
   *value = SysAllocString(target->value().c_str());
   DCHECK(*value);
   return S_OK;
 }
 
@@ skipping 83 matching lines @@
 
   if (!role)
     return E_INVALIDARG;
 
   *role = ia2_role();
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_attributes(BSTR* attributes) {
+  if (!attributes)
+    return E_INVALIDARG;
+  *attributes = nullptr;
+
   if (!instance_active())
     return E_FAIL;
 
-  if (!attributes)
-    return E_INVALIDARG;
-
-  // The iaccessible2 attributes are a set of key-value pairs
-  // separated by semicolons, with a colon between the key and the value.
   base::string16 str;
-  const std::vector<base::string16>& attributes_list = ia2_attributes();
-  for (unsigned int i = 0; i < attributes_list.size(); ++i) {
-    str += attributes_list[i] + L';';
-  }
+  for (const base::string16& attribute : ia2_attributes())
+    str += attribute + L';';
 
   if (str.empty())
     return S_FALSE;
 
   *attributes = SysAllocString(str.c_str());
   DCHECK(*attributes);
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_states(AccessibleStates* states) {
@@ skipping 461 matching lines @@
     return S_FALSE;
   }
 
   if (column < 0 || column >= columns)
     return E_INVALIDARG;
 
   const std::vector<int32_t>& cell_ids =
       GetIntListAttribute(ui::AX_ATTR_CELL_IDS);
   for (int i = 0; i < rows; ++i) {
     int cell_id = cell_ids[i * columns + column];
-    BrowserAccessibilityWin* cell = static_cast<BrowserAccessibilityWin*>(
-        manager()->GetFromID(cell_id));
+    BrowserAccessibilityWin* cell = GetFromID(cell_id);
     if (cell && cell->GetRole() == ui::AX_ROLE_COLUMN_HEADER) {
       base::string16 cell_name = cell->GetString16Attribute(
           ui::AX_ATTR_NAME);
       if (cell_name.size() > 0) {
         *description = SysAllocString(cell_name.c_str());
         return S_OK;
       }
 
       if (cell->description().size() > 0) {
         *description = SysAllocString(cell->description().c_str());
@@ skipping 24 matching lines @@
       rows <= 0) {
     return S_FALSE;
   }
 
   if (row < 0 || row >= rows || column < 0 || column >= columns)
     return E_INVALIDARG;
 
   const std::vector<int32_t>& cell_ids =
       GetIntListAttribute(ui::AX_ATTR_CELL_IDS);
   int cell_id = cell_ids[row * columns + column];
-  BrowserAccessibilityWin* cell = static_cast<BrowserAccessibilityWin*>(
-      manager()->GetFromID(cell_id));
+  BrowserAccessibilityWin* cell = GetFromID(cell_id);
   int colspan;
   if (cell &&
       cell->GetIntAttribute(
           ui::AX_ATTR_TABLE_CELL_COLUMN_SPAN, &colspan) &&
       colspan >= 1) {
     *n_columns_spanned = colspan;
     return S_OK;
   }
 
   return S_FALSE;
@@ skipping 16 matching lines @@
 
   const std::vector<int32_t>& unique_cell_ids =
       GetIntListAttribute(ui::AX_ATTR_UNIQUE_CELL_IDS);
   int cell_id_count = static_cast<int>(unique_cell_ids.size());
   if (cell_index < 0)
     return E_INVALIDARG;
   if (cell_index >= cell_id_count)
     return S_FALSE;
 
   int cell_id = unique_cell_ids[cell_index];
-  BrowserAccessibilityWin* cell =
-      manager()->GetFromID(cell_id)->ToBrowserAccessibilityWin();
+  BrowserAccessibilityWin* cell = GetFromID(cell_id);
   int col_index;
   if (cell &&
       cell->GetIntAttribute(
           ui::AX_ATTR_TABLE_CELL_COLUMN_INDEX, &col_index)) {
     *column_index = col_index;
     return S_OK;
   }
 
   return S_FALSE;
 }
@@ skipping 83 matching lines @@
     return S_FALSE;
   }
 
   if (row < 0 || row >= rows)
     return E_INVALIDARG;
 
   const std::vector<int32_t>& cell_ids =
       GetIntListAttribute(ui::AX_ATTR_CELL_IDS);
   for (int i = 0; i < columns; ++i) {
     int cell_id = cell_ids[row * columns + i];
-    BrowserAccessibilityWin* cell =
-        manager()->GetFromID(cell_id)->ToBrowserAccessibilityWin();
+    BrowserAccessibilityWin* cell = GetFromID(cell_id);
     if (cell && cell->GetRole() == ui::AX_ROLE_ROW_HEADER) {
       base::string16 cell_name = cell->GetString16Attribute(
           ui::AX_ATTR_NAME);
       if (cell_name.size() > 0) {
         *description = SysAllocString(cell_name.c_str());
         return S_OK;
       }
 
       if (cell->description().size() > 0) {
         *description = SysAllocString(cell->description().c_str());
@@ skipping 23 matching lines @@
       rows <= 0) {
     return S_FALSE;
   }
 
   if (row < 0 || row >= rows || column < 0 || column >= columns)
     return E_INVALIDARG;
 
   const std::vector<int32_t>& cell_ids =
       GetIntListAttribute(ui::AX_ATTR_CELL_IDS);
   int cell_id = cell_ids[row * columns + column];
-  BrowserAccessibilityWin* cell =
-      manager()->GetFromID(cell_id)->ToBrowserAccessibilityWin();
+  BrowserAccessibilityWin* cell = GetFromID(cell_id);
   int rowspan;
   if (cell &&
       cell->GetIntAttribute(
           ui::AX_ATTR_TABLE_CELL_ROW_SPAN, &rowspan) &&
       rowspan >= 1) {
     *n_rows_spanned = rowspan;
     return S_OK;
   }
 
   return S_FALSE;
@@ skipping 16 matching lines @@
 
   const std::vector<int32_t>& unique_cell_ids =
       GetIntListAttribute(ui::AX_ATTR_UNIQUE_CELL_IDS);
   int cell_id_count = static_cast<int>(unique_cell_ids.size());
   if (cell_index < 0)
     return E_INVALIDARG;
   if (cell_index >= cell_id_count)
     return S_FALSE;
 
   int cell_id = unique_cell_ids[cell_index];
-  BrowserAccessibilityWin* cell =
-      manager()->GetFromID(cell_id)->ToBrowserAccessibilityWin();
+  BrowserAccessibilityWin* cell = GetFromID(cell_id);
   int cell_row_index;
   if (cell &&
       cell->GetIntAttribute(
           ui::AX_ATTR_TABLE_CELL_ROW_INDEX, &cell_row_index)) {
     *row_index = cell_row_index;
     return S_OK;
   }
 
   return S_FALSE;
 }
@@ skipping 107 matching lines @@
 
   const std::vector<int32_t>& unique_cell_ids =
       GetIntListAttribute(ui::AX_ATTR_UNIQUE_CELL_IDS);
   int cell_id_count = static_cast<int>(unique_cell_ids.size());
   if (index < 0)
     return E_INVALIDARG;
   if (index >= cell_id_count)
     return S_FALSE;
 
   int cell_id = unique_cell_ids[index];
-  BrowserAccessibilityWin* cell =
-      manager()->GetFromID(cell_id)->ToBrowserAccessibilityWin();
+  BrowserAccessibilityWin* cell = GetFromID(cell_id);
   int rowspan;
   int colspan;
   if (cell &&
       cell->GetIntAttribute(
           ui::AX_ATTR_TABLE_CELL_ROW_SPAN, &rowspan) &&
       cell->GetIntAttribute(
           ui::AX_ATTR_TABLE_CELL_COLUMN_SPAN, &colspan) &&
       rowspan >= 1 &&
       colspan >= 1) {
     *row_extents = rowspan;
@@ skipping 137 matching lines @@
     return S_FALSE;
   }
   if (columns <= 0 || rows <= 0 || column < 0 || column >= columns)
     return S_FALSE;
 
   const std::vector<int32_t>& cell_ids =
       table->GetIntListAttribute(ui::AX_ATTR_CELL_IDS);
 
   for (int i = 0; i < rows; ++i) {
     int cell_id = cell_ids[i * columns + column];
-    BrowserAccessibilityWin* cell =
-        manager()->GetFromID(cell_id)->ToBrowserAccessibilityWin();
+    BrowserAccessibilityWin* cell = GetFromID(cell_id);
     if (cell && cell->GetRole() == ui::AX_ROLE_COLUMN_HEADER)
       (*n_column_header_cells)++;
   }
 
   *cell_accessibles = static_cast<IUnknown**>(CoTaskMemAlloc(
       (*n_column_header_cells) * sizeof(cell_accessibles[0])));
   int index = 0;
   for (int i = 0; i < rows; ++i) {
     int cell_id = cell_ids[i * columns + column];
     BrowserAccessibility* cell = manager()->GetFromID(cell_id);
@@ skipping 586 matching lines @@
     return E_INVALIDARG;
 
   const base::string16& text_str = GetText();
   HandleSpecialTextOffset(text_str, &start_offset);
   HandleSpecialTextOffset(text_str, &end_offset);
 
   manager()->SetTextSelection(*this, start_offset, end_offset);
   return S_OK;
 }
 
-//
-// IAccessibleText methods not implemented.
-//
-
 STDMETHODIMP BrowserAccessibilityWin::get_attributes(LONG offset,
                                                      LONG* start_offset,
                                                      LONG* end_offset,
                                                      BSTR* text_attributes) {
-  return E_NOTIMPL;
+  if (!start_offset || !end_offset || !text_attributes)
+    return E_INVALIDARG;
+
+  *start_offset = *end_offset = 0;
+  *text_attributes = nullptr;
+  if (!instance_active())
+    return E_FAIL;
+
+  const base::string16& text = GetText();
+  HandleSpecialTextOffset(text, &offset);
+  if (offset < 0 || offset > static_cast<LONG>(text.size()))
+    return E_INVALIDARG;
+
+  ComputeTextAttributes();

[dmazzoni, 2016/03/07 23:38:11]

We shouldn't compute them from scratch every time this is called.
If necessary, compute them the first time but then save it so
it doesn't need to be recomputed if the node doesn't change and
this is called again?

+  *start_offset = FindStartOfStyle(offset, ui::BACKWARDS_DIRECTION);
+  *end_offset = FindStartOfStyle(offset, ui::FORWARDS_DIRECTION);
+
+  base::string16 attributes;
+  for (base::string16& attribute : offset_to_text_attributes()[*start_offset]) {
+    attributes += attribute + L';';
+  }
+
+  if (attributes.empty())
+    return S_FALSE;
+
+  *text_attributes = SysAllocString(attributes.c_str());
+  DCHECK(*text_attributes);
+  return S_OK;
 }
 
 //
 // IAccessibleHypertext methods.
 //
 
 STDMETHODIMP BrowserAccessibilityWin::get_nHyperlinks(long* hyperlink_count) {
   if (!instance_active())
     return E_FAIL;
 
@@ skipping 10 matching lines @@
   if (!instance_active())
     return E_FAIL;
 
   if (!hyperlink ||
       index < 0 ||
       index >= static_cast<long>(hyperlinks().size())) {
     return E_INVALIDARG;
   }
 
   int32_t id = hyperlinks()[index];
-  BrowserAccessibilityWin* child =
-      manager()->GetFromID(id)->ToBrowserAccessibilityWin();
-  if (child) {
-    *hyperlink = static_cast<IAccessibleHyperlink*>(child->NewReference());
+  BrowserAccessibilityWin* link = GetFromID(id);
+  if (link) {
+    *hyperlink = static_cast<IAccessibleHyperlink*>(link->NewReference());
     return S_OK;
   }
 
   return E_FAIL;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_hyperlinkIndex(
     long char_index,
     long* hyperlink_index) {
   if (!instance_active())
@@ skipping 561 matching lines @@
 STDMETHODIMP BrowserAccessibilityWin::get_innerHTML(BSTR* innerHTML) {
   return E_NOTIMPL;
 }
 
 STDMETHODIMP
 BrowserAccessibilityWin::get_localInterface(void** local_interface) {
   return E_NOTIMPL;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_language(BSTR* language) {
-  return E_NOTIMPL;
+  if (!language)
+    return E_INVALIDARG;
+  *language = nullptr;
+
+  if (!instance_active())
+    return E_FAIL;
+
+  base::string16 lang = GetInheritedString16Attribute(ui::AX_ATTR_LANGUAGE);
+  if (lang.empty())
+    lang = L"en-US";
+
+  *language = SysAllocString(lang.c_str());
+  DCHECK(*language);
+  return S_OK;
 }
 
 //
 // ISimpleDOMText methods.
 //
 
 STDMETHODIMP BrowserAccessibilityWin::get_domText(BSTR* dom_text) {
   if (!instance_active())
     return E_FAIL;
 
@@ skipping 58 matching lines @@
   }
 
   manager()->ScrollToMakeVisible(*this, GetLocalBoundsForRange(
       start_index, end_index - start_index));
   manager()->ToBrowserAccessibilityManagerWin()->TrackScrollingObject(this);
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_fontFamily(BSTR* font_family) {
-  return E_NOTIMPL;
+  if (!font_family)
+    return E_INVALIDARG;
+  *font_family = nullptr;
+
+  if (!instance_active())
+    return E_FAIL;
+
+  base::string16 family =
+      GetInheritedString16Attribute(ui::AX_ATTR_FONT_FAMILY);
+  if (family.empty())
+    return S_FALSE;
+
+  *font_family = SysAllocString(family.c_str());
+  DCHECK(*font_family);
+  return S_OK;
 }
 
 //
 // IServiceProvider methods.
 //
 
 STDMETHODIMP BrowserAccessibilityWin::QueryService(REFGUID guid_service,
                                                    REFIID riid,
                                                    void** object) {
   if (!instance_active())
@@ skipping 244 matching lines @@
           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 invalid state for form controls and elements with aria-invalid.
-  int invalid_state;
-  if (GetIntAttribute(ui::AX_ATTR_INVALID_STATE, &invalid_state)) {
-    // TODO(nektar): Handle the possibility of having multiple aria-invalid
-    // attributes defined, e.g., "invalid:spelling,grammar".
-    switch (invalid_state) {
-      case ui::AX_INVALID_STATE_FALSE:
-        win_attributes_->ia2_attributes.push_back(L"invalid:false");
-        break;
-      case ui::AX_INVALID_STATE_TRUE:
-        win_attributes_->ia2_attributes.push_back(L"invalid:true");
-        break;
-      case ui::AX_INVALID_STATE_SPELLING:
-        win_attributes_->ia2_attributes.push_back(L"invalid:spelling");
-        break;
-      case ui::AX_INVALID_STATE_GRAMMAR:
-        win_attributes_->ia2_attributes.push_back(L"invalid:grammar");
-        break;
-      case ui::AX_INVALID_STATE_OTHER:
-        {
-          base::string16 aria_invalid_value;
-          if (GetString16Attribute(ui::AX_ATTR_ARIA_INVALID_VALUE,
-                                   &aria_invalid_value)) {
-            SanitizeStringAttributeForIA2(aria_invalid_value,
-                                          &aria_invalid_value);
-            win_attributes_->ia2_attributes.push_back(
-                L"invalid:" + aria_invalid_value);
-          } else {
-            // Set the attribute to L"true", since we cannot be more specific.
-            win_attributes_->ia2_attributes.push_back(L"invalid:true");
-          }
-        }
-        break;
-      default:
-        NOTREACHED();
-    }
-  }
-
   // 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) {
       case ui::AX_SORT_DIRECTION_UNSORTED:
         win_attributes_->ia2_attributes.push_back(L"sort:none");
         break;
       case ui::AX_SORT_DIRECTION_ASCENDING:
@@ skipping 297 matching lines @@
   if (parent) {
     hyperlink_index =
         parent->ToBrowserAccessibilityWin()->GetHyperlinkIndexFromChild(*this);
   }
 
   if (hyperlink_index >= 0)
     return true;
   return false;
 }
 
+BrowserAccessibilityWin*
+BrowserAccessibilityWin::GetHyperlinkFromHypertextOffset(int offset) const {
+  std::map<int32_t, int32_t>::iterator iterator =
+      hyperlink_offset_to_index().find(offset);
+  if (iterator == hyperlink_offset_to_index().end())
+    return nullptr;
+
+  int32_t index = iterator->second;
+  DCHECK_GE(index, 0);
+  DCHECK_LT(index, static_cast<int32_t>(hyperlinks().size()));
+  int32_t id = hyperlinks()[index];
+  BrowserAccessibilityWin* hyperlink = GetFromID(id);
+  if (!hyperlink)
+    return nullptr;
+  return hyperlink;
+}
+
 int32_t BrowserAccessibilityWin::GetHyperlinkIndexFromChild(
     const BrowserAccessibilityWin& child) const {
   if (hyperlinks().empty())
     return -1;
 
   auto iterator = std::find(
       hyperlinks().begin(), hyperlinks().end(), child.GetId());
   if (iterator == hyperlinks().end())
     return -1;
 
@@ skipping 123 matching lines @@
     return 0;
   if (endpoint_index_in_common_parent > index_in_common_parent)
     return GetText().size();
 
   NOTREACHED();
   return -1;
 }
 
 int BrowserAccessibilityWin::GetSelectionAnchor() const {
   int32_t anchor_id = manager()->GetTreeData().sel_anchor_object_id;
-  const auto anchor_object =
-      manager()->GetFromID(anchor_id)->ToBrowserAccessibilityWin();
+  const BrowserAccessibilityWin* anchor_object = GetFromID(anchor_id);
   if (!anchor_object)
     return -1;
 
   int anchor_offset = manager()->GetTreeData().sel_anchor_offset;
   return GetHypertextOffsetFromEndpoint(*anchor_object, anchor_offset);
 }
 
 int BrowserAccessibilityWin::GetSelectionFocus() const {
   int32_t focus_id = manager()->GetTreeData().sel_focus_object_id;
-  const auto focus_object =
-      manager()->GetFromID(focus_id)->ToBrowserAccessibilityWin();
+  const BrowserAccessibilityWin* focus_object = GetFromID(focus_id);
   if (!focus_object)
     return -1;
 
   int focus_offset = manager()->GetTreeData().sel_focus_offset;
   return GetHypertextOffsetFromEndpoint(*focus_object, focus_offset);
 }
 
 void BrowserAccessibilityWin::GetSelectionOffsets(
     int* selection_start, int* selection_end) const {
   DCHECK(selection_start && selection_end);
@@ skipping 29 matching lines @@
   }
 
   // The IA2 Spec says that if the largest of the two offsets falls on an
   // embedded object character and if there is a selection in that embedded
   // object, it should be incremented by one so that it points after the
   // embedded object character.
   // This is a signal to AT software that the embedded object is also part of
   // the selection.
   int* largest_offset =
       (*selection_start <= *selection_end) ? selection_end : selection_start;
-  auto current_object = const_cast<BrowserAccessibilityWin*>(this);
-  LONG hyperlink_index;
-  HRESULT hr =
-      current_object->get_hyperlinkIndex(*largest_offset, &hyperlink_index);
-  if (hr != S_OK)
+  BrowserAccessibilityWin* hyperlink =
+      GetHyperlinkFromHypertextOffset(*largest_offset);
+  if (!hyperlink)
     return;
 
-  DCHECK_GE(hyperlink_index, 0);
-  base::win::ScopedComPtr<IAccessibleHyperlink> hyperlink;
-  hr = current_object->get_hyperlink(hyperlink_index, hyperlink.Receive());
-  DCHECK(SUCCEEDED(hr));
-  base::win::ScopedComPtr<IAccessibleText> hyperlink_text;
-  hr = hyperlink.QueryInterface(hyperlink_text.Receive());
-  DCHECK(SUCCEEDED(hr));
   LONG n_selections = 0;
-  hr = hyperlink_text->get_nSelections(&n_selections);
+  HRESULT hr = hyperlink->get_nSelections(&n_selections);
   DCHECK(SUCCEEDED(hr));
   if (n_selections > 0)
     ++(*largest_offset);
 }
 
 base::string16 BrowserAccessibilityWin::GetValueText() {
   float fval;
   base::string16 value = this->value();
 
   if (value.empty() &&
@@ skipping 65 matching lines @@
              old_text.size() - common_suffix - 1,
              new_text.size() - common_suffix - 1)) {
     ++common_suffix;
   }
 
   *start = common_prefix;
   *old_len = old_text.size() - common_prefix - common_suffix;
   *new_len = new_text.size() - common_prefix - common_suffix;
 }
 
+void BrowserAccessibilityWin::ComputeTextAttributes() {
+  base::hash_map<int, std::vector<base::string16>> attributes_map;
+  int start_offset = 0;
+  for (size_t i = 0; i < PlatformChildCount(); ++i) {

[dmazzoni, 2016/03/07 23:38:11]

Why does this loop over children, but not recursively? It seems like if you have
a static text node, this isn't going to do the right thing, but also if you have
two nested spans like <b><i></i></b> it's not going to work for those either.

I think it has to be recursive.

+    const auto child = PlatformGetChild(i)->ToBrowserAccessibilityWin();
+    DCHECK(child);
+    std::vector<base::string16> attributes;
+
+    if (child->ia_role() == ui::AX_ROLE_LIST_MARKER)

[dmazzoni, 2016/03/07 23:38:11]

The LHS is an IAccessible role but the RHS is a Chrome role

Either way, add a TODO, it'd probably be better if this was computed in Blink
because there are lots of other auto-generated things

+      attributes.push_back(L"auto-generated:true");
+    else
+      attributes.push_back(L"auto-generated:false");
+
+    int color;
+    base::string16 color_value(L"transparent");
+    if (child->GetIntAttribute(ui::AX_ATTR_BACKGROUND_COLOR, &color)) {
+      unsigned int red, green, blue, alpha;
+      RGBAToColorValues(static_cast<unsigned int>(color), &red, &green, &blue,
+                        &alpha);
+      if (alpha) {
+        color_value = L"rgb(" + base::UintToString16(red) + L',' +
+                      base::UintToString16(blue) + L',' +
+                      base::UintToString16(green) + L')';
+      }
+    }
+    attributes.push_back(L"background-color:" + color_value);
+
+    if (child->GetIntAttribute(ui::AX_ATTR_COLOR, &color)) {
+      unsigned int red, green, blue, alpha;
+      RGBAToColorValues(static_cast<unsigned int>(color), &red, &green, &blue,
+                        &alpha);
+      color_value = L"rgb(" + base::UintToString16(red) + L',' +
+                    base::UintToString16(blue) + L',' +
+                    base::UintToString16(green) + L')';
+    } else {
+      color_value = L"rgb(0,0,0)";
+    }
+    attributes.push_back(L"color:" + color_value);
+
+    base::string16 font_family =
+        child->GetInheritedString16Attribute(ui::AX_ATTR_FONT_FAMILY);
+    // Attribute has no default value.
+    if (!font_family.empty()) {
+      SanitizeStringAttributeForIA2(font_family, &font_family);
+      attributes.push_back(L"font-family:" + font_family);
+    }
+
+    float font_size;
+    // Attribute has no default value.
+    if (child->GetFloatAttribute(ui::AX_ATTR_FONT_SIZE, &font_size)) {
+      // The IA2 Spec requires the value to be in pt, not in pixels.
+      // There are 72 points per inch.
+      // We assume that there are 96 pixels per inch on a standard display.
+      // TODO(nektar): Figure out the current value of pixels per inch.
+      float points = font_size * 72.0 / 96.0;
+      attributes.push_back(L"font-size:" +
+                           base::UTF8ToUTF16(base::DoubleToString(points)));
+    }
+
+    auto text_style =
+        static_cast<ui::AXTextStyle>(GetIntAttribute(ui::AX_ATTR_TEXT_STYLE));
+    if (text_style == ui::AX_TEXT_STYLE_NONE) {
+      attributes.push_back(L"font-style:normal");
+      attributes.push_back(L"font-weight:normal");
+    } else {
+      if (text_style & ui::AX_TEXT_STYLE_BOLD)
+        attributes.push_back(L"font-weight:bold");
+
+      base::string16 font_style;
+      if (text_style & ui::AX_TEXT_STYLE_ITALIC)
+        font_style += L",italic";
+      if (text_style & ui::AX_TEXT_STYLE_UNDERLINE)
+        font_style += L",underline";
+      if (text_style & ui::AX_TEXT_STYLE_LINE_THROUGH)
+        font_style += L",line-through";
+      // TODO(nektar): Support more font style attributes in Blink.
+
+      if (font_style.empty()) {
+        font_style = L"normal";
+      } else {
+        // Remove the leading comma.
+        font_style.erase(0, 1);
+      }
+      attributes.push_back(L"font-style:" + font_style);
+    }
+
+    auto invalid_state = static_cast<ui::AXInvalidState>(
+        child->GetIntAttribute(ui::AX_ATTR_INVALID_STATE));
+    switch (invalid_state) {
+      case ui::AX_INVALID_STATE_NONE:
+      case ui::AX_INVALID_STATE_FALSE:
+        attributes.push_back(L"invalid:false");
+        break;
+      case ui::AX_INVALID_STATE_TRUE:
+        attributes.push_back(L"invalid:true");
+        break;
+      case ui::AX_INVALID_STATE_SPELLING:
+      case ui::AX_INVALID_STATE_GRAMMAR: {
+        base::string16 spelling_grammar_value;
+        if (invalid_state & ui::AX_INVALID_STATE_SPELLING)
+          spelling_grammar_value = L"spelling";
+        else if (invalid_state & ui::AX_INVALID_STATE_GRAMMAR)
+          spelling_grammar_value = L"grammar";
+        else
+          spelling_grammar_value = L"spelling,grammar";
+        attributes.push_back(L"invalid:" + spelling_grammar_value);
+        break;
+      }
+      case ui::AX_INVALID_STATE_OTHER: {
+        base::string16 aria_invalid_value;
+        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 =
+        child->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);
+    }
+
+    // TODO(nektar): Add Blink support for the following attributes.
+    // Currently set to their default values as dictated by the IA2 Spec.
+    attributes.push_back(L"text-line-through-mode:continuous");
+    attributes.push_back(L"text-line-through-style:none");
+    // Default value must be the empty string.
+    attributes.push_back(L"text-line-through-text:");
+    attributes.push_back(L"text-line-through-type:none");
+    attributes.push_back(L"text-line-through-width:auto");
+    attributes.push_back(L"text-outline:false");
+    attributes.push_back(L"text-position:baseline");
+    attributes.push_back(L"text-shadow:none");
+    attributes.push_back(L"text-underline-mode:continuous");
+    attributes.push_back(L"text-underline-style:none");
+    attributes.push_back(L"text-underline-type:none");
+    attributes.push_back(L"text-underline-width:auto");
+
+    auto text_direction = static_cast<ui::AXTextDirection>(
+        child->GetIntAttribute(ui::AX_ATTR_TEXT_DIRECTION));
+    switch (text_direction) {
+      case ui::AX_TEXT_DIRECTION_NONE:
+      case ui::AX_TEXT_DIRECTION_LTR:
+        attributes.push_back(L"writing-mode:lr");
+        break;
+      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();
+    }
+
+    if (attributes_map.empty()) {
+      attributes_map[start_offset] = attributes;
+    } else {
+      // Only add the attributes for this child if we are at the start of a new
+      // style span.
+      std::vector<base::string16> previous_attributes =
+          attributes_map.rbegin()->second;
+      if (!std::equal(attributes.begin(), attributes.end(),
+                      previous_attributes.begin())) {
+        attributes_map[start_offset] = attributes;
+      }
+    }
+
+    if (child->IsTextOnlyObject())
+      start_offset += child->GetText().length();
+    else
+      start_offset += 1;
+  }
+
+  win_attributes_->offset_to_text_attributes = attributes_map;
+}
+
 void BrowserAccessibilityWin::HandleSpecialTextOffset(
     const base::string16& text,
     LONG* offset) {
   if (*offset == IA2_TEXT_OFFSET_LENGTH)
     *offset = static_cast<LONG>(text.size());
   else if (*offset == IA2_TEXT_OFFSET_CARET)
     get_caretOffset(offset);
 }
 
 ui::TextBoundaryType BrowserAccessibilityWin::IA2TextBoundaryToTextBoundary(
@@ skipping 26 matching lines @@
   if (ia2_boundary == IA2_TEXT_BOUNDARY_WORD)
     return GetWordStartBoundary(static_cast<int>(start_offset), direction);
 
   ui::TextBoundaryType boundary = IA2TextBoundaryToTextBoundary(ia2_boundary);
   const std::vector<int32_t>& line_breaks =
       GetIntListAttribute(ui::AX_ATTR_LINE_BREAKS);
   return ui::FindAccessibleTextBoundary(
       text, line_breaks, boundary, start_offset, direction);
 }
 
-BrowserAccessibilityWin* BrowserAccessibilityWin::GetFromID(int32_t id) {
-  return manager()->GetFromID(id)->ToBrowserAccessibilityWin();
+LONG BrowserAccessibilityWin::FindStartOfStyle(
+    LONG start_offset,
+    ui::TextBoundaryDirection direction) const {
+  LONG text_length = static_cast<LONG>(GetText().length());
+  DCHECK_GE(start_offset, 0);
+  DCHECK_LE(start_offset, text_length);
+
+  switch (direction) {
+    case ui::BACKWARDS_DIRECTION: {
+      if (offset_to_text_attributes().empty())
+        return 0;
+
+      auto iterator = offset_to_text_attributes().upper_bound(start_offset);
+      --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 {
+  BrowserAccessibility* object = manager()->GetFromID(id);
+  if (!object)
+    return nullptr;
+  return object->ToBrowserAccessibilityWin();
 }
 
 bool BrowserAccessibilityWin::IsListBoxOptionOrMenuListOption() {
   if (!GetParent())
     return false;
 
   int32_t role = GetRole();
   int32_t parent_role = GetParent()->GetRole();
 
   if (role == ui::AX_ROLE_LIST_BOX_OPTION &&
       parent_role == ui::AX_ROLE_LIST_BOX) {
     return true;
   }
 
   if (role == ui::AX_ROLE_MENU_LIST_OPTION &&
       parent_role == ui::AX_ROLE_MENU_LIST_POPUP) {
     return true;
   }
 
   return false;
 }
 
+void BrowserAccessibilityWin::AddRelations(
+    ui::AXIntListAttribute src_attr,
+    const base::string16& iaccessiblerelation_type) {
+  if (!HasIntListAttribute(src_attr))
+    return;
+
+  const std::vector<int32_t>& ids = GetIntListAttribute(src_attr);
+  for (size_t i = 0; i < ids.size(); ++i) {
+    CComObject<BrowserAccessibilityRelation>* relation;
+    HRESULT hr =
+        CComObject<BrowserAccessibilityRelation>::CreateInstance(&relation);
+    DCHECK(SUCCEEDED(hr));
+    relation->AddRef();
+    relation->Initialize(this, iaccessiblerelation_type);
+    relation->AddTarget(ids[i]);
+    relations_.push_back(relation);
+  }
+}
+
 void BrowserAccessibilityWin::UpdateRequiredAttributes() {
   // Expose slider value.
   if (ia_role() == ROLE_SYSTEM_PROGRESSBAR ||
       ia_role() == ROLE_SYSTEM_SCROLLBAR ||
       ia_role() == ROLE_SYSTEM_SLIDER) {
     base::string16 value_text = GetValueText();
     SanitizeStringAttributeForIA2(value_text, &value_text);
     win_attributes_->ia2_attributes.push_back(L"valuetext:" + value_text);
   }
 
@@ skipping 43 matching lines @@
   // Expose input-text type attribute.
   base::string16 type;
   base::string16 html_tag = GetString16Attribute(ui::AX_ATTR_HTML_TAG);
   if (IsSimpleTextControl() && html_tag == L"input" &&
       GetHtmlAttribute("type", &type)) {
     SanitizeStringAttributeForIA2(type, &type);
     win_attributes_->ia2_attributes.push_back(L"text-input-type:" + type);
   }
 }
 
-void BrowserAccessibilityWin::AddRelations(
-    ui::AXIntListAttribute src_attr,
-    const base::string16& iaccessiblerelation_type) {
-  if (!HasIntListAttribute(src_attr))
-    return;
-
-  const std::vector<int32_t>& ids = GetIntListAttribute(src_attr);
-  for (size_t i = 0; i < ids.size(); ++i) {
-    CComObject<BrowserAccessibilityRelation>* relation;
-    HRESULT hr = CComObject<BrowserAccessibilityRelation>::CreateInstance(
-        &relation);
-    DCHECK(SUCCEEDED(hr));
-    relation->AddRef();
-    relation->Initialize(this, iaccessiblerelation_type);
-    relation->AddTarget(ids[i]);
-    relations_.push_back(relation);
-  }
-}
-
 void BrowserAccessibilityWin::InitRoleAndState() {
   int32_t ia_role = 0;
   int32_t ia_state = 0;
   base::string16 role_name;
   int32_t ia2_role = 0;
   int32_t ia2_state = IA2_STATE_OPAQUE;
 
   if (HasState(ui::AX_STATE_BUSY))
     ia_state |= STATE_SYSTEM_BUSY;
   if (HasState(ui::AX_STATE_CHECKED))
@@ skipping 531 matching lines @@
     ia2_role = ia_role;
 
   win_attributes_->ia_role = ia_role;
   win_attributes_->ia_state = ia_state;
   win_attributes_->role_name = role_name;
   win_attributes_->ia2_role = ia2_role;
   win_attributes_->ia2_state = ia2_state;
 }
 
 }  // namespace content