Get rid of AX_LINE_BREAKS attribute to improve performance.

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>
+#include <functional>
 
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/accessibility/browser_accessibility_manager.h"
 #include "content/common/accessibility_messages.h"
 #include "ui/accessibility/ax_text_utils.h"
 #include "ui/accessibility/platform/ax_platform_node.h"
 #include "ui/gfx/geometry/rect_conversions.h"
@@ skipping 506 matching lines @@
 }
 
 int BrowserAccessibility::GetLineStartBoundary(
     int start,
     ui::TextBoundaryDirection direction,
     ui::AXTextAffinity affinity) const {
   DCHECK_GE(start, 0);
   DCHECK_LE(start, static_cast<int>(GetText().length()));
 
   if (IsSimpleTextControl()) {
-    const std::vector<int32_t>& line_breaks =
-        GetIntListAttribute(ui::AX_ATTR_LINE_BREAKS);
-    return ui::FindAccessibleTextBoundary(GetText(), line_breaks,
+    return ui::FindAccessibleTextBoundary(GetText(), ComputeLineBreaks(),
                                           ui::LINE_BOUNDARY, start, direction,
                                           affinity);
   }
 
   // Keeps track of the start offset of each consecutive line.
   int line_start = 0;
   // Keeps track of the length of each consecutive line.
   int line_length = 0;
   for (size_t i = 0; i < InternalChildCount(); ++i) {
     const BrowserAccessibility* child = InternalGetChild(i);
@@ skipping 586 matching lines @@
         if (!name.empty())
           name += " ";
         name += child_name;
       }
     }
   }
 
   return name;
 }
 
+std::vector<int> BrowserAccessibility::ComputeLineBreaks() const {
+  std::vector<int> line_breaks;
+  int offset = 0;
+  for (size_t i = 0; i < InternalChildCount(); ++i) {
+    const BrowserAccessibility* child = InternalGetChild(i);
+    DCHECK(child);
+    switch
+      child->GetRole() {
+        case ui::AX_ROLE_INLINE_TEXT_BOX:

[dmazzoni, 2016/09/02 15:55:00]

This algorithm is fine, it will certainly work correctly for plaintext

I think there might be a few cases where it doesn't do what we intend if you mix
content other than text into a paragraph. For example imagine you have a tiny
inline <img> element that happens to be the last thing on a line. I think you
still want to call IsNextSiblingOnSameLine() on that image even though it's not
an inline text box

So my initial thought is to just call IsNextSiblingOnSameLine on any leaf node

But I'm okay to land this and try to fix it better with AXPosition

+          offset += child->GetText().length();
+          if (!child->IsNextSiblingOnSameLine())
+            line_breaks.push_back(offset);
+          break;
+        case ui::AX_ROLE_LINE_BREAK:
+          line_breaks.push_back(offset);
+          offset += child->GetText().length();
+          break;
+        default:
+          std::vector<int> child_breaks = child->ComputeLineBreaks();
+        std::transform(child_breaks.begin(), child_breaks.end(), child_breaks.begin(), std::bind2nd()std::plus<int>, offset));

[dmazzoni, 2016/09/02 15:55:00]

Needs indentation

Could you write this using a lambda instead of bind2nd and plus? I think that'd
be more readable.

This involves a fair amount of copying, an alternative that comes to mind is to
use a helper that takes an offset argument, then you can do it all in one pass.

// Recursively finds line breaks in this subtree and appends them to the passed
vector, adding |offset| to each one.
void BrowserAccessibility::AppendLineBreaksWithOffset(int offset,
std::vector<int>* line_breaks) const {
}

std::vector<int> BrowserAccessibility::ComputeLineBreaks() const {
  std::vector<int> result;
  AppendLineBreaksWithOffset(0, &result);
  return result;
}

+        line_breaks.insert(line_breaks.end(), child_breaks.begin(),
+                           child_breaks.end());
+      }
+  }
+  return line_breaks;
+}
+
 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;
 }
 
@@ skipping 57 matching lines @@
       }
     }
 
     node = container;
   }
 
   return gfx::ToEnclosingRect(bounds);
 }
 
 }  // namespace content