| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "chrome_frame/test/chrome_frame_ui_test_utils.h" | |
| 6 | |
| 7 #include <windows.h> | |
| 8 | |
| 9 #include <sstream> | |
| 10 #include <stack> | |
| 11 | |
| 12 #include "base/bind.h" | |
| 13 #include "base/memory/scoped_ptr.h" | |
| 14 #include "base/message_loop/message_loop.h" | |
| 15 #include "base/path_service.h" | |
| 16 #include "base/strings/string_util.h" | |
| 17 #include "base/strings/stringprintf.h" | |
| 18 #include "base/strings/utf_string_conversions.h" | |
| 19 #include "base/win/scoped_bstr.h" | |
| 20 #include "chrome/common/chrome_paths.h" | |
| 21 #include "chrome_frame/test/win_event_receiver.h" | |
| 22 #include "chrome_frame/utils.h" | |
| 23 #include "testing/gtest/include/gtest/gtest.h" | |
| 24 #include "third_party/iaccessible2/ia2_api_all.h" | |
| 25 #include "ui/gfx/point.h" | |
| 26 #include "ui/gfx/rect.h" | |
| 27 | |
| 28 namespace chrome_frame_test { | |
| 29 | |
| 30 // Timeout for waiting on Chrome to create the accessibility tree for the DOM. | |
| 31 const int kChromeDOMAccessibilityTreeTimeoutMs = 10 * 1000; | |
| 32 | |
| 33 // Timeout for waiting on a menu to popup. | |
| 34 const int kMenuPopupTimeoutMs = 10 * 1000; | |
| 35 | |
| 36 // AccObject methods | |
| 37 AccObject::AccObject(IAccessible* accessible, int child_id) | |
| 38 : accessible_(accessible), child_id_(child_id) { | |
| 39 DCHECK(accessible); | |
| 40 if (child_id != CHILDID_SELF) { | |
| 41 base::win::ScopedComPtr<IDispatch> dispatch; | |
| 42 // This class does not support referring to a full MSAA object using the | |
| 43 // parent object and the child id. | |
| 44 HRESULT result = accessible_->get_accChild(child_id_, dispatch.Receive()); | |
| 45 if (result != S_FALSE && result != E_NOINTERFACE) { | |
| 46 LOG(ERROR) << "AccObject created which refers to full MSAA object using " | |
| 47 "parent object and child id. This should NOT be done."; | |
| 48 } | |
| 49 DCHECK(result == S_FALSE || result == E_NOINTERFACE); | |
| 50 } | |
| 51 } | |
| 52 | |
| 53 // static | |
| 54 AccObject* AccObject::CreateFromWindow(HWND hwnd) { | |
| 55 base::win::ScopedComPtr<IAccessible> accessible; | |
| 56 ::AccessibleObjectFromWindow(hwnd, OBJID_CLIENT, | |
| 57 IID_IAccessible, reinterpret_cast<void**>(accessible.Receive())); | |
| 58 if (accessible) | |
| 59 return new AccObject(accessible); | |
| 60 return NULL; | |
| 61 } | |
| 62 | |
| 63 // static | |
| 64 AccObject* AccObject::CreateFromEvent(HWND hwnd, LONG object_id, | |
| 65 LONG child_id) { | |
| 66 base::win::ScopedComPtr<IAccessible> accessible; | |
| 67 base::win::ScopedVariant acc_child_id; | |
| 68 ::AccessibleObjectFromEvent(hwnd, object_id, child_id, accessible.Receive(), | |
| 69 acc_child_id.Receive()); | |
| 70 if (accessible && acc_child_id.type() == VT_I4) | |
| 71 return new AccObject(accessible, V_I4(&acc_child_id)); | |
| 72 return NULL; | |
| 73 } | |
| 74 | |
| 75 // static | |
| 76 AccObject* AccObject::CreateFromDispatch(IDispatch* dispatch) { | |
| 77 if (dispatch) { | |
| 78 base::win::ScopedComPtr<IAccessible> accessible; | |
| 79 accessible.QueryFrom(dispatch); | |
| 80 if (accessible) | |
| 81 return new AccObject(accessible); | |
| 82 } | |
| 83 return NULL; | |
| 84 } | |
| 85 | |
| 86 // static | |
| 87 AccObject* AccObject::CreateFromPoint(int x, int y) { | |
| 88 base::win::ScopedComPtr<IAccessible> accessible; | |
| 89 base::win::ScopedVariant child_id; | |
| 90 POINT point = {x, y}; | |
| 91 ::AccessibleObjectFromPoint(point, accessible.Receive(), child_id.Receive()); | |
| 92 if (accessible && child_id.type() == VT_I4) | |
| 93 return new AccObject(accessible, V_I4(&child_id)); | |
| 94 return NULL; | |
| 95 } | |
| 96 | |
| 97 bool AccObject::DoDefaultAction() { | |
| 98 // Prevent clients from using this method to try to select menu items, which | |
| 99 // does not work with a locked desktop. | |
| 100 std::wstring class_name; | |
| 101 if (GetWindowClassName(&class_name)) { | |
| 102 DCHECK(class_name != L"#32768") << "Do not use DoDefaultAction with menus"; | |
| 103 } | |
| 104 | |
| 105 HRESULT result = accessible_->accDoDefaultAction(child_id_); | |
| 106 EXPECT_HRESULT_SUCCEEDED(result) | |
| 107 << "Could not do default action for AccObject: " << GetDescription(); | |
| 108 return SUCCEEDED(result); | |
| 109 } | |
| 110 | |
| 111 bool AccObject::LeftClick() { | |
| 112 return PostMouseClickAtCenter(WM_LBUTTONDOWN, WM_LBUTTONUP); | |
| 113 } | |
| 114 | |
| 115 bool AccObject::RightClick() { | |
| 116 return PostMouseClickAtCenter(WM_RBUTTONDOWN, WM_RBUTTONUP); | |
| 117 } | |
| 118 | |
| 119 bool AccObject::Focus() { | |
| 120 EXPECT_HRESULT_SUCCEEDED( | |
| 121 accessible_->accSelect(SELFLAG_TAKEFOCUS, child_id_)); | |
| 122 | |
| 123 // Double check that the object actually received focus. In some cases | |
| 124 // the parent object must have the focus first. | |
| 125 bool did_focus = false; | |
| 126 base::win::ScopedVariant focused; | |
| 127 if (SUCCEEDED(accessible_->get_accFocus(focused.Receive()))) { | |
| 128 if (focused.type() != VT_EMPTY) | |
| 129 did_focus = true; | |
| 130 } | |
| 131 EXPECT_TRUE(did_focus) << "Could not focus AccObject: " << GetDescription(); | |
| 132 return did_focus; | |
| 133 } | |
| 134 | |
| 135 bool AccObject::Select() { | |
| 136 // SELFLAG_TAKESELECTION needs to be combined with the focus in order to | |
| 137 // take effect. | |
| 138 int selection_flag = SELFLAG_TAKEFOCUS | SELFLAG_TAKESELECTION; | |
| 139 EXPECT_HRESULT_SUCCEEDED(accessible_->accSelect(selection_flag, child_id_)); | |
| 140 | |
| 141 // Double check that the object actually received selection. | |
| 142 bool did_select = false; | |
| 143 base::win::ScopedVariant selected; | |
| 144 if (SUCCEEDED(accessible_->get_accSelection(selected.Receive()))) { | |
| 145 if (selected.type() != VT_EMPTY) | |
| 146 did_select = true; | |
| 147 } | |
| 148 EXPECT_TRUE(did_select) << "Could not select AccObject: " << GetDescription(); | |
| 149 return did_select; | |
| 150 } | |
| 151 | |
| 152 bool AccObject::SetValue(const std::wstring& value) { | |
| 153 base::win::ScopedBstr value_bstr(value.c_str()); | |
| 154 EXPECT_HRESULT_SUCCEEDED(accessible_->put_accValue(child_id_, value_bstr)); | |
| 155 | |
| 156 // Double check that the object's value has actually changed. Some objects' | |
| 157 // values can not be changed. | |
| 158 bool did_set_value = false; | |
| 159 std::wstring actual_value = L"-"; | |
| 160 if (GetValue(&actual_value) && value == actual_value) { | |
| 161 did_set_value = true; | |
| 162 } | |
| 163 EXPECT_TRUE(did_set_value) << "Could not set value for AccObject: " | |
| 164 << GetDescription(); | |
| 165 return did_set_value; | |
| 166 } | |
| 167 | |
| 168 bool AccObject::GetName(std::wstring* name) { | |
| 169 DCHECK(name); | |
| 170 base::win::ScopedBstr name_bstr; | |
| 171 HRESULT result = accessible_->get_accName(child_id_, name_bstr.Receive()); | |
| 172 if (SUCCEEDED(result)) | |
| 173 name->assign(name_bstr, name_bstr.Length()); | |
| 174 return SUCCEEDED(result); | |
| 175 } | |
| 176 | |
| 177 bool AccObject::GetRoleText(std::wstring* role_text) { | |
| 178 DCHECK(role_text); | |
| 179 base::win::ScopedVariant role_variant; | |
| 180 if (SUCCEEDED(accessible_->get_accRole(child_id_, role_variant.Receive()))) { | |
| 181 if (role_variant.type() == VT_I4) { | |
| 182 wchar_t role_text_array[50]; | |
| 183 UINT characters = ::GetRoleText(V_I4(&role_variant), role_text_array, | |
| 184 arraysize(role_text_array)); | |
| 185 if (characters) { | |
| 186 *role_text = role_text_array; | |
| 187 return true; | |
| 188 } else { | |
| 189 LOG(ERROR) << "GetRoleText failed for role: " << V_I4(&role_variant); | |
| 190 } | |
| 191 } else if (role_variant.type() == VT_BSTR) { | |
| 192 *role_text = V_BSTR(&role_variant); | |
| 193 return true; | |
| 194 } else { | |
| 195 LOG(ERROR) << "Role was unexpected variant type: " | |
| 196 << role_variant.type(); | |
| 197 } | |
| 198 } | |
| 199 return false; | |
| 200 } | |
| 201 | |
| 202 bool AccObject::GetValue(std::wstring* value) { | |
| 203 DCHECK(value); | |
| 204 base::win::ScopedBstr value_bstr; | |
| 205 HRESULT result = accessible_->get_accValue(child_id_, value_bstr.Receive()); | |
| 206 if (SUCCEEDED(result)) | |
| 207 value->assign(value_bstr, value_bstr.Length()); | |
| 208 return SUCCEEDED(result); | |
| 209 } | |
| 210 | |
| 211 bool AccObject::GetState(int* state) { | |
| 212 DCHECK(state); | |
| 213 base::win::ScopedVariant state_variant; | |
| 214 if (SUCCEEDED(accessible_->get_accState(child_id_, | |
| 215 state_variant.Receive()))) { | |
| 216 if (state_variant.type() == VT_I4) { | |
| 217 *state = V_I4(&state_variant); | |
| 218 return true; | |
| 219 } | |
| 220 } | |
| 221 return false; | |
| 222 } | |
| 223 | |
| 224 bool AccObject::GetLocation(gfx::Rect* location) { | |
| 225 DCHECK(location); | |
| 226 long left, top, width, height; // NOLINT | |
| 227 HRESULT result = accessible_->accLocation(&left, &top, &width, &height, | |
| 228 child_id_); | |
| 229 if (SUCCEEDED(result)) | |
| 230 *location = gfx::Rect(left, top, width, height); | |
| 231 return SUCCEEDED(result); | |
| 232 } | |
| 233 | |
| 234 bool AccObject::GetLocationInClient(gfx::Rect* client_location) { | |
| 235 DCHECK(client_location); | |
| 236 gfx::Rect location; | |
| 237 if (!GetLocation(&location)) | |
| 238 return false; | |
| 239 HWND container_window = NULL; | |
| 240 if (!GetWindow(&container_window)) | |
| 241 return false; | |
| 242 POINT offset = {0, 0}; | |
| 243 if (!::ScreenToClient(container_window, &offset)) { | |
| 244 LOG(ERROR) << "Could not convert from screen to client coordinates for " | |
| 245 "window containing accessibility object: " | |
| 246 << GetDescription(); | |
| 247 return false; | |
| 248 } | |
| 249 location.Offset(offset.x, offset.y); | |
| 250 *client_location = location; | |
| 251 return true; | |
| 252 } | |
| 253 | |
| 254 AccObject* AccObject::GetParent() { | |
| 255 if (IsSimpleElement()) | |
| 256 return new AccObject(accessible_); | |
| 257 base::win::ScopedComPtr<IDispatch> dispatch; | |
| 258 if (FAILED(accessible_->get_accParent(dispatch.Receive()))) | |
| 259 return NULL; | |
| 260 return AccObject::CreateFromDispatch(dispatch.get()); | |
| 261 } | |
| 262 | |
| 263 bool AccObject::GetChildren(RefCountedAccObjectVector* client_objects) { | |
| 264 DCHECK(client_objects); | |
| 265 int child_count; | |
| 266 if (!GetChildCount(&child_count)) { | |
| 267 LOG(ERROR) << "Failed to get child count of AccObject"; | |
| 268 return false; | |
| 269 } | |
| 270 if (child_count == 0) | |
| 271 return true; | |
| 272 | |
| 273 RefCountedAccObjectVector objects; | |
| 274 // Find children using |AccessibleChildren|. | |
| 275 scoped_ptr<VARIANT[]> children(new VARIANT[child_count]); | |
| 276 long found_child_count; // NOLINT | |
| 277 if (FAILED(AccessibleChildren(accessible_, 0L, child_count, | |
| 278 children.get(), | |
| 279 &found_child_count))) { | |
| 280 LOG(ERROR) << "Failed to get children of accessible object"; | |
| 281 return false; | |
| 282 } | |
| 283 if (found_child_count > 0) { | |
| 284 for (int i = 0; i < found_child_count; i++) { | |
| 285 scoped_refptr<AccObject> obj = CreateFromVariant(this, children[i]); | |
| 286 if (obj) | |
| 287 objects.push_back(obj); | |
| 288 ::VariantClear(&children[i]); | |
| 289 } | |
| 290 } | |
| 291 | |
| 292 // In some cases, there are more children which can be found only by using | |
| 293 // the deprecated |accNavigate| method. Many of the menus, such as | |
| 294 // 'Favorites', cannot be found in IE6 using |AccessibileChildren|. Here we | |
| 295 // attempt a best effort at finding some remaining children. | |
| 296 int remaining_child_count = child_count - found_child_count; | |
| 297 scoped_refptr<AccObject> child_object; | |
| 298 if (remaining_child_count > 0) { | |
| 299 GetFromNavigation(NAVDIR_FIRSTCHILD, &child_object); | |
| 300 } | |
| 301 while (remaining_child_count > 0 && child_object) { | |
| 302 // Add to the children list if this child was not found earlier. | |
| 303 bool already_found = false; | |
| 304 for (size_t i = 0; i < objects.size(); ++i) { | |
| 305 if (child_object->Equals(objects[i])) { | |
| 306 already_found = true; | |
| 307 break; | |
| 308 } | |
| 309 } | |
| 310 if (!already_found) { | |
| 311 objects.push_back(child_object); | |
| 312 remaining_child_count--; | |
| 313 } | |
| 314 scoped_refptr<AccObject> next_child_object; | |
| 315 child_object->GetFromNavigation(NAVDIR_NEXT, &next_child_object); | |
| 316 child_object = next_child_object; | |
| 317 } | |
| 318 | |
| 319 client_objects->insert(client_objects->end(), objects.begin(), objects.end()); | |
| 320 return true; | |
| 321 } | |
| 322 | |
| 323 bool AccObject::GetChildCount(int* child_count) { | |
| 324 DCHECK(child_count); | |
| 325 *child_count = 0; | |
| 326 if (!IsSimpleElement()) { | |
| 327 long long_child_count; // NOLINT | |
| 328 if (FAILED(accessible_->get_accChildCount(&long_child_count))) | |
| 329 return false; | |
| 330 *child_count = static_cast<int>(long_child_count); | |
| 331 } | |
| 332 return true; | |
| 333 } | |
| 334 | |
| 335 bool AccObject::GetFromNavigation(long navigation_type, | |
| 336 scoped_refptr<AccObject>* object) { | |
| 337 DCHECK(object); | |
| 338 bool is_child_navigation = navigation_type == NAVDIR_FIRSTCHILD || | |
| 339 navigation_type == NAVDIR_LASTCHILD; | |
| 340 DCHECK(!is_child_navigation || !IsSimpleElement()); | |
| 341 base::win::ScopedVariant object_variant; | |
| 342 HRESULT result = accessible_->accNavigate(navigation_type, | |
| 343 child_id_, | |
| 344 object_variant.Receive()); | |
| 345 if (FAILED(result)) { | |
| 346 LOG(WARNING) << "Navigation from accessibility object failed"; | |
| 347 return false; | |
| 348 } | |
| 349 if (result == S_FALSE || object_variant.type() == VT_EMPTY) { | |
| 350 // This indicates that there was no accessibility object found by the | |
| 351 // navigation. | |
| 352 return true; | |
| 353 } | |
| 354 AccObject* navigated_to_object; | |
| 355 if (!is_child_navigation && !IsSimpleElement()) { | |
| 356 scoped_refptr<AccObject> parent = GetParent(); | |
| 357 if (!parent.get()) { | |
| 358 LOG(WARNING) << "Could not get parent for accessibiliy navigation"; | |
| 359 return false; | |
| 360 } | |
| 361 navigated_to_object = CreateFromVariant(parent, object_variant); | |
| 362 } else { | |
| 363 navigated_to_object = CreateFromVariant(this, object_variant); | |
| 364 } | |
| 365 if (!navigated_to_object) | |
| 366 return false; | |
| 367 *object = navigated_to_object; | |
| 368 return true; | |
| 369 } | |
| 370 | |
| 371 bool AccObject::GetWindow(HWND* window) { | |
| 372 DCHECK(window); | |
| 373 return SUCCEEDED(::WindowFromAccessibleObject(accessible_, window)) && window; | |
| 374 } | |
| 375 | |
| 376 bool AccObject::GetWindowClassName(std::wstring* class_name) { | |
| 377 DCHECK(class_name); | |
| 378 HWND container_window = NULL; | |
| 379 if (GetWindow(&container_window)) { | |
| 380 wchar_t class_arr[MAX_PATH]; | |
| 381 if (::GetClassName(container_window, class_arr, arraysize(class_arr))) { | |
| 382 *class_name = class_arr; | |
| 383 return true; | |
| 384 } | |
| 385 } | |
| 386 return false; | |
| 387 } | |
| 388 | |
| 389 bool AccObject::GetSelectionRange(int* start_offset, int* end_offset) { | |
| 390 DCHECK(start_offset); | |
| 391 DCHECK(end_offset); | |
| 392 base::win::ScopedComPtr<IAccessibleText> accessible_text; | |
| 393 HRESULT hr = DoQueryService(IID_IAccessibleText, | |
| 394 accessible_, | |
| 395 accessible_text.Receive()); | |
| 396 if (FAILED(hr)) { | |
| 397 LOG(ERROR) << "Could not get IAccessibleText interface. Error: " << hr | |
| 398 << "\nIs IAccessible2Proxy.dll registered?"; | |
| 399 return false; | |
| 400 } | |
| 401 | |
| 402 LONG selection_count = 0; | |
| 403 accessible_text->get_nSelections(&selection_count); | |
| 404 LONG start = 0, end = 0; | |
| 405 if (selection_count > 0) { | |
| 406 if (FAILED(accessible_text->get_selection(0, &start, &end))) { | |
| 407 LOG(WARNING) << "Could not get first selection"; | |
| 408 return false; | |
| 409 } | |
| 410 } | |
| 411 *start_offset = start; | |
| 412 *end_offset = end; | |
| 413 return true; | |
| 414 } | |
| 415 | |
| 416 bool AccObject::GetSelectedText(std::wstring* text) { | |
| 417 DCHECK(text); | |
| 418 int start = 0, end = 0; | |
| 419 if (!GetSelectionRange(&start, &end)) | |
| 420 return false; | |
| 421 base::win::ScopedComPtr<IAccessibleText> accessible_text; | |
| 422 HRESULT hr = DoQueryService(IID_IAccessibleText, | |
| 423 accessible_, | |
| 424 accessible_text.Receive()); | |
| 425 if (FAILED(hr)) { | |
| 426 LOG(ERROR) << "Could not get IAccessibleText interface. Error: " << hr | |
| 427 << "\nIs IAccessible2Proxy.dll registered?"; | |
| 428 return false; | |
| 429 } | |
| 430 base::win::ScopedBstr text_bstr; | |
| 431 if (FAILED(accessible_text->get_text(start, end, text_bstr.Receive()))) { | |
| 432 LOG(WARNING) << "Could not get text from selection range"; | |
| 433 return false; | |
| 434 } | |
| 435 text->assign(text_bstr, text_bstr.Length()); | |
| 436 return true; | |
| 437 } | |
| 438 | |
| 439 bool AccObject::IsSimpleElement() { | |
| 440 return V_I4(&child_id_) != CHILDID_SELF; | |
| 441 } | |
| 442 | |
| 443 bool AccObject::Equals(AccObject* other) { | |
| 444 if (other) { | |
| 445 DCHECK(child_id_.type() == VT_I4 && other->child_id_.type() == VT_I4); | |
| 446 return accessible_.get() == other->accessible_.get() && | |
| 447 V_I4(&child_id_) == V_I4(&other->child_id_); | |
| 448 } | |
| 449 return false; | |
| 450 } | |
| 451 | |
| 452 std::wstring AccObject::GetDescription() { | |
| 453 std::wstring name = L"-", role_text = L"-", value = L"-"; | |
| 454 if (GetName(&name)) | |
| 455 name = L"'" + name + L"'"; | |
| 456 if (GetRoleText(&role_text)) | |
| 457 role_text = L"'" + role_text + L"'"; | |
| 458 if (GetValue(&value)) | |
| 459 value = L"'" + value + L"'"; | |
| 460 int state = 0; | |
| 461 GetState(&state); | |
| 462 return base::StringPrintf(L"[%ls, %ls, %ls, 0x%x]", name.c_str(), | |
| 463 role_text.c_str(), value.c_str(), state); | |
| 464 } | |
| 465 | |
| 466 std::wstring AccObject::GetTree() { | |
| 467 std::wostringstream string_stream; | |
| 468 string_stream << L"Accessibility object tree:" << std::endl; | |
| 469 string_stream << L"[name, role_text, value, state]" << std::endl; | |
| 470 | |
| 471 std::stack<std::pair<scoped_refptr<AccObject>, int> > pairs; | |
| 472 pairs.push(std::make_pair(this, 0)); | |
| 473 while (!pairs.empty()) { | |
| 474 scoped_refptr<AccObject> object = pairs.top().first; | |
| 475 int depth = pairs.top().second; | |
| 476 pairs.pop(); | |
| 477 | |
| 478 for (int i = 0; i < depth; ++i) | |
| 479 string_stream << L" "; | |
| 480 string_stream << object->GetDescription() << std::endl; | |
| 481 | |
| 482 RefCountedAccObjectVector children; | |
| 483 if (object->GetChildren(&children)) { | |
| 484 for (int i = static_cast<int>(children.size()) - 1; i >= 0; --i) | |
| 485 pairs.push(std::make_pair(children[i], depth + 1)); | |
| 486 } | |
| 487 } | |
| 488 return string_stream.str(); | |
| 489 } | |
| 490 | |
| 491 // static | |
| 492 AccObject* AccObject::CreateFromVariant(AccObject* object, | |
| 493 const VARIANT& variant) { | |
| 494 IAccessible* accessible = object->accessible_; | |
| 495 if (V_VT(&variant) == VT_I4) { | |
| 496 // According to MSDN, a server is allowed to return a full Accessibility | |
| 497 // object using the parent object and the child id. If get_accChild is | |
| 498 // called with the id, the server must return the actual IAccessible | |
| 499 // interface. Do that here to get an actual IAccessible interface if | |
| 500 // possible, since this class operates under the assumption that if the | |
| 501 // child id is not CHILDID_SELF, the object is a simple element. See the | |
| 502 // DCHECK in the constructor. | |
| 503 base::win::ScopedComPtr<IDispatch> dispatch; | |
| 504 HRESULT result = accessible->get_accChild(variant, | |
| 505 dispatch.Receive()); | |
| 506 if (result == S_FALSE || result == E_NOINTERFACE) { | |
| 507 // The object in question really is a simple element. | |
| 508 return new AccObject(accessible, V_I4(&variant)); | |
| 509 } else if (SUCCEEDED(result)) { | |
| 510 // The object in question was actually a full object. | |
| 511 return CreateFromDispatch(dispatch.get()); | |
| 512 } | |
| 513 VLOG(1) << "Failed to determine if child id refers to a full " | |
| 514 << "object. Error: " << result << std::endl | |
| 515 << "Parent object: " << base::WideToUTF8(object->GetDescription()) | |
| 516 << std::endl << "Child ID: " << V_I4(&variant); | |
| 517 return NULL; | |
| 518 } else if (V_VT(&variant) == VT_DISPATCH) { | |
| 519 return CreateFromDispatch(V_DISPATCH(&variant)); | |
| 520 } | |
| 521 LOG(WARNING) << "Unrecognizable child type"; | |
| 522 return NULL; | |
| 523 } | |
| 524 | |
| 525 bool AccObject::PostMouseClickAtCenter(int button_down, int button_up) { | |
| 526 std::wstring class_name; | |
| 527 if (!GetWindowClassName(&class_name)) { | |
| 528 LOG(ERROR) << "Could not get class name of window for accessibility " | |
| 529 << "object: " << GetDescription(); | |
| 530 return false; | |
| 531 } | |
| 532 gfx::Rect location; | |
| 533 if (class_name == L"#32768") { | |
| 534 // For some reason, it seems that menus expect screen coordinates. | |
| 535 if (!GetLocation(&location)) | |
| 536 return false; | |
| 537 } else { | |
| 538 if (!GetLocationInClient(&location)) | |
| 539 return false; | |
| 540 } | |
| 541 | |
| 542 gfx::Point center = location.CenterPoint(); | |
| 543 return PostMouseButtonMessages(button_down, button_up, | |
| 544 center.x(), center.y()); | |
| 545 } | |
| 546 | |
| 547 bool AccObject::PostMouseButtonMessages( | |
| 548 int button_down, int button_up, int x, int y) { | |
| 549 HWND container_window; | |
| 550 if (!GetWindow(&container_window)) | |
| 551 return false; | |
| 552 | |
| 553 LPARAM coordinates = MAKELPARAM(x, y); | |
| 554 ::PostMessage(container_window, button_down, 0, coordinates); | |
| 555 ::PostMessage(container_window, button_up, 0, coordinates); | |
| 556 return true; | |
| 557 } | |
| 558 | |
| 559 // AccObjectMatcher methods | |
| 560 AccObjectMatcher::AccObjectMatcher(const std::wstring& name, | |
| 561 const std::wstring& role_text, | |
| 562 const std::wstring& value) | |
| 563 : name_(name), role_text_(role_text), value_(value) { | |
| 564 } | |
| 565 | |
| 566 bool AccObjectMatcher::FindHelper(AccObject* object, | |
| 567 scoped_refptr<AccObject>* match) const { | |
| 568 if (DoesMatch(object)) { | |
| 569 *match = object; | |
| 570 } else { | |
| 571 // Try to match the children of |object|. | |
| 572 AccObject::RefCountedAccObjectVector children; | |
| 573 if (!object->GetChildren(&children)) { | |
| 574 LOG(ERROR) << "Could not get children of AccObject"; | |
| 575 return false; | |
| 576 } | |
| 577 for (size_t i = 0; i < children.size(); ++i) { | |
| 578 if (!FindHelper(children[i], match)) { | |
| 579 return false; | |
| 580 } | |
| 581 if (*match) | |
| 582 break; | |
| 583 } | |
| 584 } | |
| 585 return true; | |
| 586 } | |
| 587 | |
| 588 bool AccObjectMatcher::Find(AccObject* object, | |
| 589 scoped_refptr<AccObject>* match) const { | |
| 590 DCHECK(object); | |
| 591 DCHECK(match); | |
| 592 *match = NULL; | |
| 593 return FindHelper(object, match); | |
| 594 } | |
| 595 | |
| 596 bool AccObjectMatcher::FindInWindow(HWND hwnd, | |
| 597 scoped_refptr<AccObject>* match) const { | |
| 598 scoped_refptr<AccObject> object(AccObject::CreateFromWindow(hwnd)); | |
| 599 if (!object) { | |
| 600 VLOG(1) << "Failed to get accessible object from window"; | |
| 601 return false; | |
| 602 } | |
| 603 return Find(object.get(), match); | |
| 604 } | |
| 605 | |
| 606 bool AccObjectMatcher::DoesMatch(AccObject* object) const { | |
| 607 DCHECK(object); | |
| 608 bool does_match = true; | |
| 609 std::wstring name, role_text, value; | |
| 610 if (name_.length()) { | |
| 611 object->GetName(&name); | |
| 612 does_match = MatchPattern(StringToUpperASCII(name), | |
| 613 StringToUpperASCII(name_)); | |
| 614 } | |
| 615 if (does_match && role_text_.length()) { | |
| 616 object->GetRoleText(&role_text); | |
| 617 does_match = MatchPattern(role_text, role_text_); | |
| 618 } | |
| 619 if (does_match && value_.length()) { | |
| 620 object->GetValue(&value); | |
| 621 does_match = MatchPattern(value, value_); | |
| 622 } | |
| 623 return does_match; | |
| 624 } | |
| 625 | |
| 626 std::wstring AccObjectMatcher::GetDescription() const { | |
| 627 std::wostringstream ss; | |
| 628 ss << L"["; | |
| 629 if (name_.length()) | |
| 630 ss << L"Name: '" << name_ << L"', "; | |
| 631 if (role_text_.length()) | |
| 632 ss << L"Role: '" << role_text_ << L"', "; | |
| 633 if (value_.length()) | |
| 634 ss << L"Value: '" << value_ << L"'"; | |
| 635 ss << L"]"; | |
| 636 return ss.str(); | |
| 637 } | |
| 638 | |
| 639 // AccEventObserver methods | |
| 640 AccEventObserver::AccEventObserver() | |
| 641 : event_handler_(new EventHandler(this)), | |
| 642 is_watching_(false) { | |
| 643 event_receiver_.SetListenerForEvents(this, EVENT_SYSTEM_MENUPOPUPSTART, | |
| 644 EVENT_OBJECT_VALUECHANGE); | |
| 645 } | |
| 646 | |
| 647 AccEventObserver::~AccEventObserver() { | |
| 648 event_handler_->observer_ = NULL; | |
| 649 } | |
| 650 | |
| 651 void AccEventObserver::WatchForOneValueChange(const AccObjectMatcher& matcher) { | |
| 652 is_watching_ = true; | |
| 653 watching_for_matcher_ = matcher; | |
| 654 } | |
| 655 | |
| 656 void AccEventObserver::OnEventReceived(DWORD event, | |
| 657 HWND hwnd, | |
| 658 LONG object_id, | |
| 659 LONG child_id) { | |
| 660 // Process events in a separate task to stop reentrancy problems. | |
| 661 DCHECK(base::MessageLoop::current()); | |
| 662 base::MessageLoop::current()->PostTask( | |
| 663 FROM_HERE, base::Bind(&EventHandler::Handle, event_handler_.get(), event, | |
| 664 hwnd, object_id, child_id)); | |
| 665 } | |
| 666 | |
| 667 // AccEventObserver::EventHandler methods | |
| 668 AccEventObserver::EventHandler::EventHandler(AccEventObserver* observer) | |
| 669 : observer_(observer) { | |
| 670 } | |
| 671 | |
| 672 void AccEventObserver::EventHandler::Handle(DWORD event, | |
| 673 HWND hwnd, | |
| 674 LONG object_id, | |
| 675 LONG child_id) { | |
| 676 if (!observer_) | |
| 677 return; | |
| 678 | |
| 679 switch (event) { | |
| 680 case EVENT_SYSTEM_MENUPOPUPSTART: | |
| 681 observer_->OnMenuPopup(hwnd); | |
| 682 break; | |
| 683 case IA2_EVENT_DOCUMENT_LOAD_COMPLETE: | |
| 684 observer_->OnAccDocLoad(hwnd); | |
| 685 break; | |
| 686 case IA2_EVENT_TEXT_CARET_MOVED: { | |
| 687 scoped_refptr<AccObject> object( | |
| 688 AccObject::CreateFromEvent(hwnd, object_id, child_id)); | |
| 689 if (object) | |
| 690 observer_->OnTextCaretMoved(hwnd, object.get()); | |
| 691 break; | |
| 692 } | |
| 693 case EVENT_OBJECT_VALUECHANGE: | |
| 694 if (observer_->is_watching_) { | |
| 695 scoped_refptr<AccObject> object( | |
| 696 AccObject::CreateFromEvent(hwnd, object_id, child_id)); | |
| 697 if (object) { | |
| 698 if (observer_->watching_for_matcher_.DoesMatch(object.get())) { | |
| 699 // Stop watching before calling OnAccValueChange in case the | |
| 700 // client invokes our watch method during the call. | |
| 701 observer_->is_watching_ = false; | |
| 702 std::wstring new_value; | |
| 703 if (object->GetValue(&new_value)) { | |
| 704 observer_->OnAccValueChange(hwnd, object.get(), new_value); | |
| 705 } | |
| 706 } | |
| 707 } | |
| 708 } | |
| 709 break; | |
| 710 default: | |
| 711 break; | |
| 712 } | |
| 713 } | |
| 714 | |
| 715 // Other methods | |
| 716 bool FindAccObjectInWindow(HWND hwnd, const AccObjectMatcher& matcher, | |
| 717 scoped_refptr<AccObject>* object) { | |
| 718 DCHECK(object); | |
| 719 EXPECT_TRUE(matcher.FindInWindow(hwnd, object)); | |
| 720 EXPECT_TRUE(*object) << "Element not found for matcher: " | |
| 721 << matcher.GetDescription(); | |
| 722 if (!*object) | |
| 723 DumpAccessibilityTreeForWindow(hwnd); | |
| 724 return *object; | |
| 725 } | |
| 726 | |
| 727 void DumpAccessibilityTreeForWindow(HWND hwnd) { | |
| 728 scoped_refptr<AccObject> object(AccObject::CreateFromWindow(hwnd)); | |
| 729 if (object) | |
| 730 std::wcout << object->GetTree(); | |
| 731 else | |
| 732 std::cout << "Could not get IAccessible for window" << std::endl; | |
| 733 } | |
| 734 | |
| 735 bool IsDesktopUnlocked() { | |
| 736 HDESK desk = ::OpenInputDesktop(0, FALSE, DESKTOP_SWITCHDESKTOP); | |
| 737 if (desk) | |
| 738 ::CloseDesktop(desk); | |
| 739 return desk; | |
| 740 } | |
| 741 | |
| 742 base::FilePath GetIAccessible2ProxyStubPath() { | |
| 743 base::FilePath path; | |
| 744 PathService::Get(chrome::DIR_APP, &path); | |
| 745 return path.AppendASCII("IAccessible2Proxy.dll"); | |
| 746 } | |
| 747 | |
| 748 } // namespace chrome_frame_test | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 126143005:
Remove Chrome Frame code and resources. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src