Skip to content

Commit

Permalink
Revert "ax_dump_tree"
Browse files Browse the repository at this point in the history 
This reverts commit 9675416.

Reason for revert:

Findit (https://goo.gl/kROfz5) identified CL at revision 509495 as the
culprit for failures in the build cycles as shown on:
https://findit-for-me.appspot.com/waterfall/culprit?key=ag9zfmZpbmRpdC1mb3ItbWVyRAsSDVdmU3VzcGVjdGVkQ0wiMWNocm9taXVtLzk2NzU0MTYxMzU4YTUyNTdhOThlOGYyZmM1ZTI1OGQyZWQ4MzU4MTIM

Sample Failed Build: https://ci.chromium.org/buildbot/chromium/Mac/33798

Original change's description:
> ax_dump_tree
> 
> Standalone executable tool that helps developers view IAccessible2 object trees from any application.
> This tool is an alternative to AccProbe, which is buggy, and AViewer, which is not feature rich.
> The first version of ax_dump_tree is barebones and simply displays events on console, but has
> a lot of room for future expansion (e.g., serve info to a GUI, dump the tree structure etc.).
> The tool is similar is use to ax_dump_events.
> 
> As an example of how this makes easier, when there is a bug with NVDA/JAWS in Chrome that doesn't 
> occur with Firefox, we can look at the object tree emitted by Firefox for the same content.
> 
> The ax_dump_tree tool shares code and formatting with the DumpAccessibilityTree browsertests. 
> 
> Use as follows:
> ax_dump_tree --pid=[processid]
> ax_dump_tree --window=[hwnd]   (start with 0x to use hex value)
> 
> Bug: 771747
> Change-Id: I330d2aba8b004e679e9a8d15b1c288ae5460e83e
> Reviewed-on: https://chromium-review.googlesource.com/700725
> Commit-Queue: Aaron Leventhal <aleventhal@chromium.org>
> Reviewed-by: Dirk Pranke <dpranke@chromium.org>
> Reviewed-by: Nektarios Paisios <nektar@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#509495}

Change-Id: I884d4ee2b277755da5067557f4b771db0bd3340d
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: 771747
Reviewed-on: https://chromium-review.googlesource.com/724001
Cr-Commit-Position: refs/heads/master@{#509516}
  • Loading branch information
Findit committed Oct 17, 2017
1 parent 9d7a30e commit 3ab8994
Show file tree
Hide file tree
Showing 13 changed files with 60 additions and 378 deletions.
4 changes: 0 additions & 4 deletions BUILD.gn
View file
Original file line number Diff line number Diff line change
Expand Up @@ -392,13 +392,9 @@ group("gn_all") {
]
}

# Accessibility API debugging tools.
if (is_win || is_mac) {
deps += [ "//tools/accessibility/inspect:ax_dump_events" ]
}
if (is_win) {
deps += [ "//tools/accessibility/inspect:ax_dump_tree" ]
}

if (is_linux) {
# The following are definitely linux-only.
Expand Down
2 changes: 0 additions & 2 deletions content/browser/accessibility/accessibility_event_recorder_win.cc
View file
Original file line number Diff line number Diff line change
Expand Up @@ -109,8 +109,6 @@ class AccessibilityEventRecorderWin : public AccessibilityEventRecorder {

HWINEVENTHOOK win_event_hook_handle_;
static AccessibilityEventRecorderWin* instance_;

// Initializes COM services when standalone dump events tool is used.
base::win::ScopedCOMInitializer com_initializer;
};

Expand Down
9 changes: 1 addition & 8 deletions content/browser/accessibility/accessibility_tree_formatter.cc
View file
Original file line number Diff line number Diff line change
Expand Up @@ -45,12 +45,6 @@ void AccessibilityTreeFormatter::FormatAccessibilityTree(
RecursiveFormatAccessibilityTree(*(dict.get()), contents);
}

void AccessibilityTreeFormatter::FormatAccessibilityTree(
const base::DictionaryValue& dict,
base::string16* contents) {
RecursiveFormatAccessibilityTree(dict, contents);
}

void AccessibilityTreeFormatter::RecursiveFormatAccessibilityTree(
const base::DictionaryValue& dict, base::string16* contents, int depth) {
base::string16 indent = base::string16(depth * kIndentSymbolCount,
Expand All @@ -70,8 +64,7 @@ void AccessibilityTreeFormatter::RecursiveFormatAccessibilityTree(
return;

const base::ListValue* children;
if (!dict.GetList(kChildrenDictAttr, &children))
return;
dict.GetList(kChildrenDictAttr, &children);
const base::DictionaryValue* child_dict;
for (size_t i = 0; i < children->GetSize(); i++) {
children->GetDictionary(i, &child_dict);
Expand Down
13 changes: 0 additions & 13 deletions content/browser/accessibility/accessibility_tree_formatter.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -11,13 +11,11 @@

#include "base/files/file_path.h"
#include "base/macros.h"
#include "base/process/process_handle.h"
#include "base/strings/string16.h"
#include "base/strings/utf_string_conversions.h"
#include "base/values.h"
#include "content/browser/accessibility/browser_accessibility.h"
#include "content/common/content_export.h"
#include "ui/gfx/native_widget_types.h"

namespace {
const char kChildrenDictAttr[] = "children";
Expand Down Expand Up @@ -77,23 +75,12 @@ class CONTENT_EXPORT AccessibilityTreeFormatter {
// "children": [ ]
// } ]
// }
// Build an accessibility tree for the current Chrome app.
virtual std::unique_ptr<base::DictionaryValue> BuildAccessibilityTree(
BrowserAccessibility* root) = 0;

// Build an accessibility tree for any process with a window.
virtual std::unique_ptr<base::DictionaryValue>
BuildAccessibilityTreeForProcess(base::ProcessId pid) = 0;

// Build an accessibility tree for any window.
virtual std::unique_ptr<base::DictionaryValue>
BuildAccessibilityTreeForWindow(gfx::AcceleratedWidget widget) = 0;

// Dumps a BrowserAccessibility tree into a string.
void FormatAccessibilityTree(
BrowserAccessibility* root, base::string16* contents);
void FormatAccessibilityTree(const base::DictionaryValue& tree_node,
base::string16* contents);

// Set regular expression filters that apply to each component of every
// line before it's output.
Expand Down
14 changes: 0 additions & 14 deletions content/browser/accessibility/accessibility_tree_formatter_browser.cc
View file
Original file line number Diff line number Diff line change
Expand Up @@ -17,20 +17,6 @@ AccessibilityTreeFormatterBrowser::BuildAccessibilityTree(
return dict;
}

std::unique_ptr<base::DictionaryValue>
AccessibilityTreeFormatterBrowser::BuildAccessibilityTreeForProcess(
base::ProcessId pid) {
NOTREACHED();
return nullptr;
}

std::unique_ptr<base::DictionaryValue>
AccessibilityTreeFormatterBrowser::BuildAccessibilityTreeForWindow(
gfx::AcceleratedWidget widget) {
NOTREACHED();
return nullptr;
}

void AccessibilityTreeFormatterBrowser::RecursiveBuildAccessibilityTree(
const BrowserAccessibility& node,
base::DictionaryValue* dict) {
Expand Down
6 changes: 0 additions & 6 deletions content/browser/accessibility/accessibility_tree_formatter_browser.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -25,12 +25,6 @@ class CONTENT_EXPORT AccessibilityTreeFormatterBrowser
std::unique_ptr<base::DictionaryValue> BuildAccessibilityTree(
BrowserAccessibility* root) override;

std::unique_ptr<base::DictionaryValue> BuildAccessibilityTreeForProcess(
base::ProcessId pid) override;

std::unique_ptr<base::DictionaryValue> BuildAccessibilityTreeForWindow(
gfx::AcceleratedWidget widget) override;

protected:
void RecursiveBuildAccessibilityTree(const BrowserAccessibility& node,
base::DictionaryValue* dict);
Expand Down
195 changes: 53 additions & 142 deletions content/browser/accessibility/accessibility_tree_formatter_win.cc
View file
Original file line number Diff line number Diff line change
Expand Up @@ -20,7 +20,6 @@
#include "base/strings/utf_string_conversions.h"
#include "base/values.h"
#include "base/win/scoped_bstr.h"
#include "base/win/scoped_com_initializer.h"
#include "base/win/scoped_comptr.h"
#include "base/win/scoped_variant.h"
#include "content/browser/accessibility/accessibility_tree_formatter_utils_win.h"
Expand All @@ -29,32 +28,6 @@
#include "third_party/iaccessible2/ia2_api_all.h"
#include "ui/base/win/atl_module.h"

namespace {

struct HwndWithProcId {
HwndWithProcId(const base::ProcessId id) : pid(id), hwnd(nullptr) {}
const base::ProcessId pid;
HWND hwnd;
};

BOOL CALLBACK EnumWindowsProcPid(HWND hwnd, LPARAM lParam) {
DWORD process_id;
GetWindowThreadProcessId(hwnd, &process_id);
HwndWithProcId* hwnd_with_proc_id = (HwndWithProcId*)lParam;
if (process_id == static_cast<DWORD>(hwnd_with_proc_id->pid)) {
hwnd_with_proc_id->hwnd = hwnd;
;
return FALSE;
}
return TRUE;
}

HWND GetHwndForProcess(base::ProcessId pid) {
HwndWithProcId hwnd_with_proc_id(pid);
EnumWindows(&EnumWindowsProcPid, (LPARAM)&hwnd_with_proc_id);
return hwnd_with_proc_id.hwnd;
}
} // namespace

namespace content {

Expand All @@ -65,10 +38,6 @@ class AccessibilityTreeFormatterWin : public AccessibilityTreeFormatter {

std::unique_ptr<base::DictionaryValue> BuildAccessibilityTree(
BrowserAccessibility* start) override;
std::unique_ptr<base::DictionaryValue> BuildAccessibilityTreeForWindow(
gfx::AcceleratedWidget hwnd) override;
std::unique_ptr<base::DictionaryValue> BuildAccessibilityTreeForProcess(
base::ProcessId pid) override;
std::unique_ptr<base::DictionaryValue> BuildAccessibilityTree(
base::win::ScopedComPtr<IAccessible> start,
LONG window_x = 0,
Expand Down Expand Up @@ -108,9 +77,6 @@ class AccessibilityTreeFormatterWin : public AccessibilityTreeFormatter {
void AddIA2ValueProperties(const base::win::ScopedComPtr<IAccessible>,
base::DictionaryValue* dict);
base::string16 ToString(const base::DictionaryValue& node) override;

// Initializes COM services when standalone dump events tool is used.
base::win::ScopedCOMInitializer com_initializer;
};

// static
Expand Down Expand Up @@ -211,7 +177,9 @@ AccessibilityTreeFormatterWin::BuildAccessibilityTree(
BrowserAccessibility* start_node) {
DCHECK(start_node);

base::win::ScopedVariant variant_self(CHILDID_SELF);
VARIANT variant_self;
variant_self.vt = VT_I4;
variant_self.lVal = CHILDID_SELF;
LONG root_x, root_y, root_width, root_height;
BrowserAccessibility* root =
start_node->manager()->GetRootManager()->GetRoot();
Expand All @@ -238,33 +206,6 @@ AccessibilityTreeFormatterWin::BuildAccessibilityTree(
return dict;
}

std::unique_ptr<base::DictionaryValue>
AccessibilityTreeFormatterWin::BuildAccessibilityTreeForWindow(
gfx::AcceleratedWidget hwnd) {
if (!hwnd)
return nullptr;

// Get IAccessible* for window
base::win::ScopedComPtr<IAccessible> start;
HRESULT hr = ::AccessibleObjectFromWindow(
hwnd, static_cast<DWORD>(OBJID_CLIENT), IID_PPV_ARGS(&start));
if (FAILED(hr))
return nullptr;

auto dict(std::make_unique<base::DictionaryValue>());
RecursiveBuildAccessibilityTree(start, dict.get(), 0, 0);

return dict;
}

std::unique_ptr<base::DictionaryValue>
AccessibilityTreeFormatterWin::BuildAccessibilityTreeForProcess(
base::ProcessId pid) {
// Get HWND for process id.
HWND hwnd = GetHwndForProcess(pid);
return BuildAccessibilityTreeForWindow(hwnd);
}

void AccessibilityTreeFormatterWin::RecursiveBuildAccessibilityTree(
const base::win::ScopedComPtr<IAccessible> node,
base::DictionaryValue* dict,
Expand All @@ -278,55 +219,19 @@ void AccessibilityTreeFormatterWin::RecursiveBuildAccessibilityTree(
if (S_OK != node->get_accChildCount(&child_count))
return;

std::unique_ptr<VARIANT[]> children_array(new VARIANT[child_count]);
LONG obtained_count = 0;
HRESULT hr = AccessibleChildren(node.Get(), 0, child_count,
children_array.get(), &obtained_count);
if (hr != S_OK)
return;

for (LONG index = 0; index < obtained_count; index++) {
base::win::ScopedVariant child_variant;
child_variant.Reset(
children_array[index]); // Sets without adding another reference.
std::unique_ptr<base::DictionaryValue> child_dict(
new base::DictionaryValue);
base::win::ScopedComPtr<IDispatch> dispatch;
if (child_variant.type() == VT_DISPATCH) {
dispatch = V_DISPATCH(child_variant.ptr());
} else if (child_variant.type() == VT_I4) {
HRESULT hr = node->get_accChild(child_variant, dispatch.GetAddressOf());
if (FAILED(hr)) {
child_dict->SetString("error",
base::ASCIIToUTF16("<Error retrieving child>"));
} else if (!dispatch) {
// Partial child does not have its own object.
// Add minimal info -- role and name.
base::win::ScopedVariant role_variant;
if (SUCCEEDED(
node->get_accRole(child_variant, role_variant.Receive()))) {
if (role_variant.type() == VT_I4) {
child_dict->SetString("role",
base::ASCIIToUTF16(" <partial child>"));
}
}
base::win::ScopedBstr temp_bstr;
if (S_OK == node->get_accName(child_variant, temp_bstr.Receive())) {
base::string16 name = base::string16(temp_bstr, temp_bstr.Length());
child_dict->SetString("name", name);
}
}
} else {
child_dict->SetString("error",
base::ASCIIToUTF16("<Unknown child type>"));
}
if (dispatch) {
base::win::ScopedComPtr<IAccessible> accessible;
if (SUCCEEDED(dispatch.As(&accessible)))
RecursiveBuildAccessibilityTree(accessible, child_dict.get(), root_x,
root_y);
for (int index = 1; index <= child_count; ++index) {
base::win::ScopedVariant childid_index(index);
base::win::ScopedComPtr<IDispatch> child_dispatch;
base::win::ScopedComPtr<IAccessible> child_accessible;
if (S_OK ==
node->get_accChild(childid_index, child_dispatch.GetAddressOf()) &&
S_OK == child_dispatch.CopyTo(child_accessible.GetAddressOf())) {
std::unique_ptr<base::DictionaryValue> child_dict(
new base::DictionaryValue);
RecursiveBuildAccessibilityTree(child_accessible, child_dict.get(),
root_x, root_y);
children->Append(std::move(child_dict));
}
children->Append(std::move(child_dict));
}
dict->Set(kChildrenDictAttr, std::move(children));
}
Expand Down Expand Up @@ -381,27 +286,26 @@ void AccessibilityTreeFormatterWin::AddProperties(
}
}

base::string16 RoleVariantToString(const base::win::ScopedVariant& role) {
if (role.type() == VT_I4) {
return IAccessible2RoleToString(V_I4(role.ptr()));
} else if (role.type() == VT_BSTR) {
BSTR bstr_role = V_BSTR(role.ptr());
return base::string16(bstr_role, SysStringLen(bstr_role));
}
return base::string16();
}

void AccessibilityTreeFormatterWin::AddMSAAProperties(
const base::win::ScopedComPtr<IAccessible> node,
base::DictionaryValue* dict,
LONG root_x,
LONG root_y) {
base::win::ScopedVariant variant_self(CHILDID_SELF);
VARIANT variant_self;
variant_self.vt = VT_I4;
variant_self.lVal = CHILDID_SELF;

base::win::ScopedBstr temp_bstr;
base::win::ScopedVariant ia_role_variant;

LONG ia_role = 0;
if (SUCCEEDED(node->get_accRole(variant_self, ia_role_variant.Receive()))) {
dict->SetString("role", RoleVariantToString(ia_role_variant));
VARIANT ia_role_variant;
if (SUCCEEDED(node->get_accRole(variant_self, &ia_role_variant))) {
if (ia_role_variant.vt == VT_I4) {
ia_role = ia_role_variant.lVal;
dict->SetString("role", IAccessible2RoleToString(ia_role));
} else if (ia_role_variant.vt == VT_BSTR) {
dict->SetString("role", base::string16(ia_role_variant.bstrVal));
}
}

// If S_FALSE it means there is no name
Expand All @@ -419,10 +323,22 @@ void AccessibilityTreeFormatterWin::AddMSAAProperties(
temp_bstr.Reset();

int32_t ia_state = 0;
base::win::ScopedVariant ia_state_variant;
if (node->get_accState(variant_self, ia_state_variant.Receive()) == S_OK &&
ia_state_variant.type() == VT_I4) {
ia_state = ia_state_variant.ptr()->intVal;
VARIANT ia_state_variant;
if (node->get_accState(variant_self, &ia_state_variant) == S_OK &&
ia_state_variant.vt == VT_I4) {
ia_state = ia_state_variant.intVal;

if (true /* reduced_flakiness_mode_ */) { // TODO
// Avoid flakiness: these states depend on whether the window is focused
// and the position of the mouse cursor.
ia_state &= ~STATE_SYSTEM_HOTTRACKED;
ia_state &= ~STATE_SYSTEM_OFFSCREEN;

// For testing, having the focused state may also cause flakiness if the
// window isn't in the foreground.
ia_state &= ~STATE_SYSTEM_FOCUSED;
}

std::vector<base::string16> state_strings;
IAccessibleStateToStringVector(ia_state, &state_strings);
std::unique_ptr<base::ListValue> states(new base::ListValue());
Expand Down Expand Up @@ -728,28 +644,23 @@ void AccessibilityTreeFormatterWin::AddIA2ValueProperties(
if (S_OK != QueryIAccessibleValue(node.Get(), ia2value.GetAddressOf()))
return; // No IA2Value, we are finished with this node.

base::win::ScopedVariant currentValue;
if (ia2value->get_currentValue(currentValue.Receive()) == S_OK)
dict->SetDouble("currentValue", V_R8(currentValue.ptr()));
VARIANT currentValue;
if (ia2value->get_currentValue(&currentValue) == S_OK)
dict->SetDouble("currentValue", V_R8(&currentValue));

base::win::ScopedVariant minimumValue;
if (ia2value->get_minimumValue(minimumValue.Receive()) == S_OK)
dict->SetDouble("minimumValue", V_R8(minimumValue.ptr()));
VARIANT minimumValue;
if (ia2value->get_minimumValue(&minimumValue) == S_OK)
dict->SetDouble("minimumValue", V_R8(&minimumValue));

base::win::ScopedVariant maximumValue;
if (ia2value->get_maximumValue(maximumValue.Receive()) == S_OK)
dict->SetDouble("maximumValue", V_R8(maximumValue.ptr()));
VARIANT maximumValue;
if (ia2value->get_maximumValue(&maximumValue) == S_OK)
dict->SetDouble("maximumValue", V_R8(&maximumValue));
}

base::string16 AccessibilityTreeFormatterWin::ToString(
const base::DictionaryValue& dict) {
base::string16 line;

base::string16 error_value;
if (dict.GetString("error", &error_value)) {
return error_value;
}

base::string16 role_value;
dict.GetString("role", &role_value);
WriteAttribute(true, base::UTF16ToUTF8(role_value), &line);
Expand Down
Loading

0 comments on commit 3ab8994

Please sign in to comment.