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>
 
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/win/enum_variant.h"
 #include "base/win/scoped_comptr.h"
 #include "base/win/windows_version.h"
 #include "content/browser/accessibility/browser_accessibility_manager_win.h"
 #include "content/browser/accessibility/browser_accessibility_state_impl.h"
 #include "content/common/accessibility_messages.h"
 #include "content/public/common/content_client.h"
+#include "third_party/skia/include/core/SkColor.h"
 #include "ui/accessibility/ax_text_utils.h"
 #include "ui/base/win/accessibility_ids_win.h"
 #include "ui/base/win/accessibility_misc_utils.h"
 #include "ui/base/win/atl_module.h"
 
 namespace content {
 
 // These nonstandard GUIDs are taken directly from the Mozilla sources
 // (accessible/src/msaa/nsAccessNodeWrap.cpp); some documentation is here:
 // http://developer.mozilla.org/en/Accessibility/AT-APIs/ImplementationFeatures/MSAA
@@ skipping 75 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*>(
       ToBrowserAccessibilityWin(result)->NewReference());
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityRelation::get_targets(long max_targets,
                                                        IUnknown** targets,
@@ skipping 414 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 = SkColorGetR(color);
+    unsigned int green = SkColorGetG(color);
+    unsigned int blue = SkColorGetB(color);
     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 127 matching lines @@
       manager()->ScrollToMakeVisible(
           *this, gfx::Rect(r.right(), r.y(), 0, r.height()));
       break;
     case IA2_SCROLL_TYPE_ANYWHERE:
     default:
       manager()->ScrollToMakeVisible(*this, r);
       break;
   }
 
   manager()->ToBrowserAccessibilityManagerWin()->TrackScrollingObject(this);
-
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::scrollToPoint(
     IA2CoordinateType coordinate_type,
     LONG x,
     LONG y) {
   if (!instance_active())
     return E_FAIL;
 
@@ skipping 313 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 =
-      ToBrowserAccessibilityWin(manager()->GetFromID(cell_id));
+  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 =
-        ToBrowserAccessibilityWin(manager()->GetFromID(cell_id));
+    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 =
-      ToBrowserAccessibilityWin(manager()->GetFromID(cell_id));
+  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 =
-      ToBrowserAccessibilityWin(manager()->GetFromID(cell_id));
+  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 =
-      ToBrowserAccessibilityWin(manager()->GetFromID(cell_id));
+  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 =
-        ToBrowserAccessibilityWin(manager()->GetFromID(cell_id));
+    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;
+
+  MayBeComputeStyles();

[dmazzoni, 2016/03/14 17:38:21]

nit: no capital B in maybe, just spell it MaybeComputeStyles

I'd also like ComputeStylesIfNeeded

+  *start_offset = FindStartOfStyle(offset, ui::BACKWARDS_DIRECTION);
+  *end_offset = FindStartOfStyle(offset, ui::FORWARDS_DIRECTION);
+
+  base::string16 attributes_str;
+  const std::vector<base::string16>& attributes =
+      offset_to_text_attributes().find(*start_offset)->second;
+  for (const base::string16& attribute : attributes) {
+    attributes_str += attribute + L';';
+  }
+
+  if (attributes.empty())
+    return S_FALSE;
+
+  *text_attributes = SysAllocString(attributes_str.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 =
-      ToBrowserAccessibilityWin(manager()->GetFromID(id));
-  if (child) {
-    *hyperlink = static_cast<IAccessibleHyperlink*>(child->NewReference());
-    return S_OK;
-  }
+  BrowserAccessibilityWin* link = GetFromID(id);
+  if (!link)
+    return E_FAIL;
 
-  return E_FAIL;
+  *hyperlink = static_cast<IAccessibleHyperlink*>(link->NewReference());
+  return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_hyperlinkIndex(
     long char_index,
     long* hyperlink_index) {
   if (!instance_active())
     return E_FAIL;
 
   if (!hyperlink_index)
     return E_INVALIDARG;
@@ skipping 557 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 59 matching lines @@
 
     return;
   }
 
   // Construct the hypertext for this node, which contains the concatenation
   // of all of the static text and widespace of this node's children and an
   // embedded object character for all the other children. Build up a map from
   // the character index of each embedded object character to the id of the
   // child object it points to.
   for (unsigned int i = 0; i < PlatformChildCount(); ++i) {
-    BrowserAccessibilityWin* child =
-        ToBrowserAccessibilityWin(PlatformGetChild(i));
+    const auto child = ToBrowserAccessibilityWin(PlatformGetChild(i));
     DCHECK(child);
     // Similar to Firefox, we don't expose text-only objects in IA2 hypertext.
     if (child->IsTextOnlyObject()) {
       win_attributes_->hypertext += child->name();
     } else {
       int32_t char_offset = static_cast<int32_t>(GetText().size());
       int32_t child_id = child->GetId();
       int32_t index = hyperlinks().size();
       win_attributes_->hyperlink_offset_to_index[char_offset] = index;
       win_attributes_->hyperlinks.push_back(child_id);
@@ skipping 117 matching lines @@
 
 bool BrowserAccessibilityWin::IsNative() const {
   return true;
 }
 
 void BrowserAccessibilityWin::OnLocationChanged() {
   manager()->ToBrowserAccessibilityManagerWin()->MaybeCallNotifyWinEvent(
       EVENT_OBJECT_LOCATIONCHANGE, this);
 }
 
+std::vector<base::string16> BrowserAccessibilityWin::ComputeTextAttributes()
+    const {
+  std::vector<base::string16> attributes;
+
+  // We include list markers for now, but there might be other objects that are
+  // auto generated.
+  // TODO(nektar): Compute what objects are auto-generated in Blink.
+  if (GetRole() == ui::AX_ROLE_LIST_MARKER)
+    attributes.push_back(L"auto-generated:true");
+  else
+    attributes.push_back(L"auto-generated:false");
+
+  int color;
+  base::string16 color_value(L"transparent");
+  if (GetIntAttribute(ui::AX_ATTR_BACKGROUND_COLOR, &color)) {
+    unsigned int alpha = SkColorGetA(color);
+    unsigned int red = SkColorGetR(color);
+    unsigned int green = SkColorGetG(color);
+    unsigned int blue = SkColorGetB(color);
+    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 (GetIntAttribute(ui::AX_ATTR_COLOR, &color)) {
+    unsigned int red = SkColorGetR(color);
+    unsigned int green = SkColorGetG(color);
+    unsigned int blue = SkColorGetB(color);
+    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(
+      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 (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>(
+      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(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>(
+      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();
+  }
+
+  return attributes;
+}
+
 BrowserAccessibilityWin* BrowserAccessibilityWin::NewReference() {
   AddRef();
   return this;
 }
 
 BrowserAccessibilityWin* BrowserAccessibilityWin::GetTargetFromChildID(
     const VARIANT& var_id) {
   if (var_id.vt != VT_I4)
     return NULL;
 
@@ skipping 79 matching lines @@
   if (parent) {
     hyperlink_index =
         ToBrowserAccessibilityWin(parent)->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 =
-      ToBrowserAccessibilityWin(manager()->GetFromID(anchor_id));
+  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 =
-      ToBrowserAccessibilityWin(manager()->GetFromID(focus_id));
+  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::MayBeComputeStyles() {
+  if (!offset_to_text_attributes().empty())
+    return;
+
+  base::hash_map<int, std::vector<base::string16>> attributes_map;
+  if (PlatformIsLeaf()) {
+    attributes_map[0] = ComputeTextAttributes();
+    win_attributes_->offset_to_text_attributes = attributes_map;

[dmazzoni, 2016/03/14 17:38:21]

This is a deep copy. Instead you could either make attribute_map a reference up
at the top:

auto& attributes_map = win_attributes_->offset_to_text_attributes;

Alternatively, you could swap it:
win_attributes_->offset_to_text_attributes.swap(attributes_map);

+    return;
+  }
+
+  int start_offset = 0;
+  for (size_t i = 0; i < PlatformChildCount(); ++i) {
+    const auto child = ToBrowserAccessibilityWin(PlatformGetChild(i));
+    DCHECK(child);
+    std::vector<base::string16> attributes(child->ComputeTextAttributes());
+
+    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) {
+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);

[dmazzoni, 2016/03/14 17:38:20]

Just checking, is it correct that both BACKWARDS and FORWARDS call upper_bound?
Shouldn't one call lower_bound to be symmetrical?

+      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));
 }
 
 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 542 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