tree 451d878b8d7acf32f5f519689d89e916c47c7838
parent b79fc12878d2017cca1ae8fcf319751fb7b67445
author Mason Freed <masonfreed@chromium.org> 1558741255 +0000
committer Commit Bot <commit-bot@chromium.org> 1558741255 +0000

Revert "DevTools: Make Preview Pane Accessible"

This reverts commit 58040a832bb68a52529638518de36be17c65547f.

Reason for revert: New test in this CL is flaky or failing:

https://ci.chromium.org/p/chromium/builders/ci/WebKit%20Linux%20Trusty%20MSAN

https://test-results.appspot.com/data/layout_results/WebKit_Linux_Trusty_MSAN/14730/webkit_layout_tests/layout-test-results/results.html

Bug: 967064


Original change's description:
> DevTools: Make Preview Pane Accessible
> 
> The preview pane previously lacked keyboard controls for navigating
> through the JSON and XML views, the Font view unnecessarily read out the
> content of the view (the alphabet) when accessed via screen reader, and
> the Image view did not allow a screen reader user to access the size and
> mime type of the image.
> 
> This patch fixes these issues by making the JSON and XML treeOutlines
> selectable so they can be accessed via keyboard and by displaying
> keyboard focus within the treeOutline. In the Font view, the element
> containing the sample text is marked so that a screen reader will not
> read the contents, but rather will read the source url of the font. In
> the Image view, a tab stop was moved from a parent element to the image
> itself and a label was added that reads the source url of the image.
> 
> JSON view before: https://imgur.com/BWczsAL
> JSON view after, without keyboard focus: (same as before)
> JSON view after, with keyboard focus: https://imgur.com/gD0rNSB
> 
> XML view before: https://imgur.com/Ec9b5kf
> XML view after, without focus: https://imgur.com/NEqUgpt
> XML view after, with focus: https://imgur.com/0csIpQ3
> 
> Change-Id: Id8bacdc593a5b562069fddb70452902ebad934e0
> Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1551384
> Commit-Queue: Amanda Baker <ambake@microsoft.com>
> Reviewed-by: Erik Luo <luoe@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#663263}

TBR=einbinder@chromium.org,luoe@chromium.org,jeffish@microsoft.com,jalissia@microsoft.com,ambake@microsoft.com,juxiao@microsoft.com

Change-Id: I54ef03d14a548b61c15106a2c4ebcc710f1d3b62
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1629126
Reviewed-by: Mason Freed <masonfreed@chromium.org>
Commit-Queue: Mason Freed <masonfreed@chromium.org>
Cr-Commit-Position: refs/heads/master@{#663321}
