Implemented the reporting of text style and language information on Windows.

content/browser/accessibility/browser_accessibility.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.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
@@ skipping 212 matching lines @@
     uint32_t child_index) const {
   if (!node_ || !manager_ || child_index >= InternalChildCount())
     return nullptr;
 
   const auto child_node = node_->ChildAtIndex(child_index);
   DCHECK(child_node);
   return manager_->GetFromAXNode(child_node);
 }
 
 BrowserAccessibility* BrowserAccessibility::GetParent() const {
-  if (!node_ || !manager_)
-    return NULL;
+  if (!instance_active())
+    return nullptr;
+
   ui::AXNode* parent = node_->parent();
   if (parent)
     return manager_->GetFromAXNode(parent);
 
   return manager_->GetParentNodeFromParentTree();
 }
 
 BrowserAccessibility* BrowserAccessibility::InternalGetParent() const {
   if (!node_ || !manager_)
     return nullptr;
@@ skipping 110 matching lines @@
     if (child_end < start)
       continue;
 
     int overlap_start = std::max(start, child_start);
     int overlap_end = std::min(end, child_end);
 
     int local_start = overlap_start - child_start;
     int local_end = overlap_end - child_start;
 
     gfx::Rect child_rect = child->GetLocation();
-    int text_direction = child->GetIntAttribute(
-        ui::AX_ATTR_TEXT_DIRECTION);
+    auto text_direction = static_cast<ui::AXTextDirection>(
+        child->GetIntAttribute(ui::AX_ATTR_TEXT_DIRECTION));
     const std::vector<int32_t>& character_offsets =
         child->GetIntListAttribute(ui::AX_ATTR_CHARACTER_OFFSETS);
     int start_pixel_offset =
         local_start > 0 ? character_offsets[local_start - 1] : 0;
     int end_pixel_offset =
         local_end > 0 ? character_offsets[local_end - 1] : 0;
 
     gfx::Rect child_overlap_rect;
     switch (text_direction) {
       case ui::AX_TEXT_DIRECTION_NONE:
@@ skipping 247 matching lines @@
 float BrowserAccessibility::GetFloatAttribute(
     ui::AXFloatAttribute attribute) const {
   return GetData().GetFloatAttribute(attribute);
 }
 
 bool BrowserAccessibility::GetFloatAttribute(
     ui::AXFloatAttribute attribute, float* value) const {
   return GetData().GetFloatAttribute(attribute, value);
 }
 
+bool BrowserAccessibility::HasInheritedStringAttribute(
+    ui::AXStringAttribute attribute) const {
+  if (!instance_active())
+    return false;
+
+  if (GetData().HasStringAttribute(attribute))
+    return true;
+  return GetParent() && GetParent()->HasInheritedStringAttribute(attribute);
+}
+
+std::string BrowserAccessibility::GetInheritedStringAttribute(
+    ui::AXStringAttribute attribute) const {
+  if (!instance_active())
+    return std::string();
+
+  std::string value;
+  if (GetInheritedStringAttribute(attribute, &value))
+    return value;
+  return std::string();
+}
+
+bool BrowserAccessibility::GetInheritedStringAttribute(
+    ui::AXStringAttribute attribute,
+    std::string* value) const {
+  if (!instance_active()) {
+    *value = std::string();
+    return false;
+  }
+
+  if (GetData().GetStringAttribute(attribute, value))
+    return true;
+  return GetParent() &&
+         GetParent()->GetData().GetStringAttribute(attribute, value);
+}
+
+base::string16 BrowserAccessibility::GetInheritedString16Attribute(
+    ui::AXStringAttribute attribute) const {
+  if (!instance_active())
+    return base::string16();
+
+  base::string16 value;
+  if (GetInheritedString16Attribute(attribute, &value))
+    return value;
+  return base::string16();
+}
+
+bool BrowserAccessibility::GetInheritedString16Attribute(
+    ui::AXStringAttribute attribute,
+    base::string16* value) const {
+  if (!instance_active()) {
+    *value = base::string16();
+    return false;
+  }
+
+  if (GetData().GetString16Attribute(attribute, value))
+    return true;
+  return GetParent() &&
+         GetParent()->GetData().GetString16Attribute(attribute, value);
+}
+
 bool BrowserAccessibility::HasIntAttribute(
     ui::AXIntAttribute attribute) const {
   return GetData().HasIntAttribute(attribute);
 }
 
 int BrowserAccessibility::GetIntAttribute(ui::AXIntAttribute attribute) const {
   return GetData().GetIntAttribute(attribute);
 }
 
 bool BrowserAccessibility::GetIntAttribute(
@@ skipping 198 matching lines @@
 base::string16 BrowserAccessibility::GetInnerText() const {
   if (IsTextOnlyObject())
     return GetString16Attribute(ui::AX_ATTR_NAME);
 
   base::string16 text;
   for (size_t i = 0; i < InternalChildCount(); ++i)
     text += InternalGetChild(i)->GetInnerText();
   return text;
 }
 
+// static
+// TODO(nektar): Figure out if there is an existing Skia function to use

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

You can use SkColorGetR, etc. from SkColor.h

+// instead.
+void BrowserAccessibility::RGBAToColorValues(unsigned int color,
+                                             unsigned int* red,
+                                             unsigned int* green,
+                                             unsigned int* blue,
+                                             unsigned int* alpha) {
+  DCHECK(red && green && blue && alpha);
+  *alpha = (color >> 24) & 0xFF;
+  *red = (color >> 16) & 0xFF;
+  *green = (color >> 8) & 0xFF;
+  *blue = color & 0xFF;
+}
+
 void BrowserAccessibility::FixEmptyBounds(gfx::Rect* bounds) const
 {
   if (bounds->width() > 0 && bounds->height() > 0)
     return;
 
   for (size_t i = 0; i < InternalChildCount(); ++i) {
     // Compute the bounds of each child - this calls FixEmptyBounds
     // recursively if necessary.
     BrowserAccessibility* child = InternalGetChild(i);
     gfx::Rect child_bounds = child->GetLocalBoundsRect();
@@ skipping 47 matching lines @@
       }
       need_to_offset_web_area = true;
     }
     parent = parent->GetParent();
   }
 
   return bounds;
 }
 
 }  // namespace content