Cleanup AutomationUtil.findNodeUntil, fix wrapping when moving by line,

Cleanup AutomationUtil.findNodeUntil, fix wrapping when moving by line

1. AutomationUtil.findNodeUntil isn't entirely clear due to the use of a callback that wants to keep track of the previous node being visited. This has since become wrong because of the changes made to AutomationTreeWalker. Instead, let's just call AutomationUtil.findNextNode which should gibve us the proper linearization. Take pairs in order and apply the predicate.

2. wrapping by line didn't quite work as expected because of the asymmetric nature of the linearization. We need to get to the end when wrapping from the beginning to the end and start applying our predicate. Note that this is subject to some weird corner cases depending on how we write the predicates (e.g. ones that check for children).

3. Ensure we consider invisible nodes to be leaves. They should also be ignored when encountered (this is already done).

TEST=navigate around using ChromeVox Next on the shelf. Observe desirable behaviors.

Committed: https://crrev.com/a135032a36858abd06d90ea8273b0a406079e9c6
Cr-Commit-Position: refs/heads/master@{#371620}

[David Tseng, 2016-01-23 01:52:44]

Description was changed from

==========
Cleanup
==========

to

==========
Cleanup AutomationUtil.findNodeUntil, fix wrapping when moving by line, and
consider line ranges that cover an entire node a range (not a subrange).

1. AutomationUtil.findNodeUntil isn't entirely clear due to the use of a
callback that wants to keep track of the previous node being visited. This has
since become wrong because of the changes made to AutomationTreeWalker. Instead,
let's just call AutomationUtil.findNextNode which should gibve us the proper
linearization. Take pairs in order and apply the predicate.

2. wrapping by line didn't quite work as expected because of the asymmetric
nature of the linearization. We need to get to the end when wrapping from the
beginning to the end and start applying our predicate. Note that this is subject
to some weird corner cases depending on how we write the predicates (e.g. ones
that check for children).

3. Ensure we consider invisible nodes to be leaves. They should also be ignored
when encountered (this is already done).

4. A range that
- starts and ends at the same node
- starts at index 0 and ends at index length

should be considered a range (not a subnode range). The output system treats
these two things differently. The subnode range does not have roles/earcons
outputted.

TEST=navigate around using ChromeVox Next on the shelf. Observe desirable
behaviors.
==========

[David Tseng, 2016-01-23 01:52:44]

dtseng@chromium.org changed reviewers:
+ dmazzoni@chromium.org

[David Tseng, 2016-01-23 01:55:42]

Description was changed from

==========
Cleanup AutomationUtil.findNodeUntil, fix wrapping when moving by line, and
consider line ranges that cover an entire node a range (not a subrange).

1. AutomationUtil.findNodeUntil isn't entirely clear due to the use of a
callback that wants to keep track of the previous node being visited. This has
since become wrong because of the changes made to AutomationTreeWalker. Instead,
let's just call AutomationUtil.findNextNode which should gibve us the proper
linearization. Take pairs in order and apply the predicate.

2. wrapping by line didn't quite work as expected because of the asymmetric
nature of the linearization. We need to get to the end when wrapping from the
beginning to the end and start applying our predicate. Note that this is subject
to some weird corner cases depending on how we write the predicates (e.g. ones
that check for children).

3. Ensure we consider invisible nodes to be leaves. They should also be ignored
when encountered (this is already done).

4. A range that
- starts and ends at the same node
- starts at index 0 and ends at index length

should be considered a range (not a subnode range). The output system treats
these two things differently. The subnode range does not have roles/earcons
outputted.

TEST=navigate around using ChromeVox Next on the shelf. Observe desirable
behaviors.
==========

to

==========
Cleanup AutomationUtil.findNodeUntil, fix wrapping when moving by line, and
consider line ranges that cover an entire node a range (not a subrange).

1. AutomationUtil.findNodeUntil isn't entirely clear due to the use of a
callback that wants to keep track of the previous node being visited. This has
since become wrong because of the changes made to AutomationTreeWalker. Instead,
let's just call AutomationUtil.findNextNode which should gibve us the proper
linearization. Take pairs in order and apply the predicate.

2. wrapping by line didn't quite work as expected because of the asymmetric
nature of the linearization. We need to get to the end when wrapping from the
beginning to the end and start applying our predicate. Note that this is subject
to some weird corner cases depending on how we write the predicates (e.g. ones
that check for children).

3. Ensure we consider invisible nodes to be leaves. They should also be ignored
when encountered (this is already done).

4. A range that
- starts and ends at the same node
- starts at index 0 and ends at index getText() length

should be considered a range (not a subnode range). The output system treats
these two things differently. The subnode range does not have roles/earcons
outputted.

TEST=navigate around using ChromeVox Next on the shelf. Observe desirable
behaviors.
==========

[David Tseng, 2016-01-23 02:35:36]

Description was changed from

==========
Cleanup AutomationUtil.findNodeUntil, fix wrapping when moving by line, and
consider line ranges that cover an entire node a range (not a subrange).

1. AutomationUtil.findNodeUntil isn't entirely clear due to the use of a
callback that wants to keep track of the previous node being visited. This has
since become wrong because of the changes made to AutomationTreeWalker. Instead,
let's just call AutomationUtil.findNextNode which should gibve us the proper
linearization. Take pairs in order and apply the predicate.

2. wrapping by line didn't quite work as expected because of the asymmetric
nature of the linearization. We need to get to the end when wrapping from the
beginning to the end and start applying our predicate. Note that this is subject
to some weird corner cases depending on how we write the predicates (e.g. ones
that check for children).

3. Ensure we consider invisible nodes to be leaves. They should also be ignored
when encountered (this is already done).

4. A range that
- starts and ends at the same node
- starts at index 0 and ends at index getText() length

should be considered a range (not a subnode range). The output system treats
these two things differently. The subnode range does not have roles/earcons
outputted.

TEST=navigate around using ChromeVox Next on the shelf. Observe desirable
behaviors.
==========

to

==========
Cleanup AutomationUtil.findNodeUntil, fix wrapping when moving by line

1. AutomationUtil.findNodeUntil isn't entirely clear due to the use of a
callback that wants to keep track of the previous node being visited. This has
since become wrong because of the changes made to AutomationTreeWalker. Instead,
let's just call AutomationUtil.findNextNode which should gibve us the proper
linearization. Take pairs in order and apply the predicate.

2. wrapping by line didn't quite work as expected because of the asymmetric
nature of the linearization. We need to get to the end when wrapping from the
beginning to the end and start applying our predicate. Note that this is subject
to some weird corner cases depending on how we write the predicates (e.g. ones
that check for children).

3. Ensure we consider invisible nodes to be leaves. They should also be ignored
when encountered (this is already done).

TEST=navigate around using ChromeVox Next on the shelf. Observe desirable
behaviors.
==========

[dmazzoni, 2016-01-26 19:50:30]

lgtm

[David Tseng, 2016-01-26 21:50:51]

The CQ bit was checked by dtseng@chromium.org

[commit-bot: I haz the power, 2016-01-26 21:51:44]

CQ is trying da patch. Follow status at
 https://chromium-cq-status.appspot.com/patch-status/1622803002/40001
View timeline at
 https://chromium-cq-status.appspot.com/patch-timeline/1622803002/40001

[commit-bot: I haz the power, 2016-01-26 22:37:25]

Description was changed from

==========
Cleanup AutomationUtil.findNodeUntil, fix wrapping when moving by line

1. AutomationUtil.findNodeUntil isn't entirely clear due to the use of a
callback that wants to keep track of the previous node being visited. This has
since become wrong because of the changes made to AutomationTreeWalker. Instead,
let's just call AutomationUtil.findNextNode which should gibve us the proper
linearization. Take pairs in order and apply the predicate.

2. wrapping by line didn't quite work as expected because of the asymmetric
nature of the linearization. We need to get to the end when wrapping from the
beginning to the end and start applying our predicate. Note that this is subject
to some weird corner cases depending on how we write the predicates (e.g. ones
that check for children).

3. Ensure we consider invisible nodes to be leaves. They should also be ignored
when encountered (this is already done).

TEST=navigate around using ChromeVox Next on the shelf. Observe desirable
behaviors.
==========

to

==========
Cleanup AutomationUtil.findNodeUntil, fix wrapping when moving by line

1. AutomationUtil.findNodeUntil isn't entirely clear due to the use of a
callback that wants to keep track of the previous node being visited. This has
since become wrong because of the changes made to AutomationTreeWalker. Instead,
let's just call AutomationUtil.findNextNode which should gibve us the proper
linearization. Take pairs in order and apply the predicate.

2. wrapping by line didn't quite work as expected because of the asymmetric
nature of the linearization. We need to get to the end when wrapping from the
beginning to the end and start applying our predicate. Note that this is subject
to some weird corner cases depending on how we write the predicates (e.g. ones
that check for children).

3. Ensure we consider invisible nodes to be leaves. They should also be ignored
when encountered (this is already done).

TEST=navigate around using ChromeVox Next on the shelf. Observe desirable
behaviors.
==========

[commit-bot: I haz the power, 2016-01-26 22:37:26]

Committed patchset #3 (id:40001)

[commit-bot: I haz the power, 2016-01-26 22:38:01]

Description was changed from

==========
Cleanup AutomationUtil.findNodeUntil, fix wrapping when moving by line

1. AutomationUtil.findNodeUntil isn't entirely clear due to the use of a
callback that wants to keep track of the previous node being visited. This has
since become wrong because of the changes made to AutomationTreeWalker. Instead,
let's just call AutomationUtil.findNextNode which should gibve us the proper
linearization. Take pairs in order and apply the predicate.

2. wrapping by line didn't quite work as expected because of the asymmetric
nature of the linearization. We need to get to the end when wrapping from the
beginning to the end and start applying our predicate. Note that this is subject
to some weird corner cases depending on how we write the predicates (e.g. ones
that check for children).

3. Ensure we consider invisible nodes to be leaves. They should also be ignored
when encountered (this is already done).

TEST=navigate around using ChromeVox Next on the shelf. Observe desirable
behaviors.
==========

to

==========
Cleanup AutomationUtil.findNodeUntil, fix wrapping when moving by line

1. AutomationUtil.findNodeUntil isn't entirely clear due to the use of a
callback that wants to keep track of the previous node being visited. This has
since become wrong because of the changes made to AutomationTreeWalker. Instead,
let's just call AutomationUtil.findNextNode which should gibve us the proper
linearization. Take pairs in order and apply the predicate.

2. wrapping by line didn't quite work as expected because of the asymmetric
nature of the linearization. We need to get to the end when wrapping from the
beginning to the end and start applying our predicate. Note that this is subject
to some weird corner cases depending on how we write the predicates (e.g. ones
that check for children).

3. Ensure we consider invisible nodes to be leaves. They should also be ignored
when encountered (this is already done).

TEST=navigate around using ChromeVox Next on the shelf. Observe desirable
behaviors.

Committed: https://crrev.com/a135032a36858abd06d90ea8273b0a406079e9c6
Cr-Commit-Position: refs/heads/master@{#371620}
==========

[commit-bot: I haz the power, 2016-01-26 22:38:03]

Patchset 3 (id:??) landed as
https://crrev.com/a135032a36858abd06d90ea8273b0a406079e9c6
Cr-Commit-Position: refs/heads/master@{#371620}