Add a method for setting the value of an Accessibility object....

chrome_frame/test/chrome_frame_ui_test_utils.cc

 // Copyright (c) 2010 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 "chrome_frame/test/chrome_frame_ui_test_utils.h"
 
 #include <windows.h>
 
 #include <sstream>
 #include <stack>
 
 #include "base/message_loop.h"
 #include "base/scoped_bstr_win.h"
 #include "base/scoped_ptr.h"
 #include "base/string_util.h"
+#include "base/utf_string_conversions.h"
 #include "gfx/rect.h"
 #include "chrome_frame/test/win_event_receiver.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace chrome_frame_test {
 
 // Timeout for waiting on Chrome to create the accessibility tree for the DOM.
 const int kChromeDOMAccessibilityTreeTimeoutMs = 10 * 1000;
 
 // Timeout for waiting on a menu to popup.
@@ skipping 20 matching lines @@
 AccObject* AccObject::CreateFromWindow(HWND hwnd) {
   ScopedComPtr<IAccessible> accessible;
   AccessibleObjectFromWindow(hwnd, OBJID_CLIENT,
       IID_IAccessible, reinterpret_cast<void**>(accessible.Receive()));
   if (accessible)
     return new AccObject(accessible);
   return NULL;
 }
 
 // static
+AccObject* AccObject::CreateFromEvent(HWND hwnd, LONG object_id,
+                                      LONG child_id) {
+  ScopedComPtr<IAccessible> accessible;
+  ScopedVariant acc_child_id;
+  AccessibleObjectFromEvent(hwnd, object_id, child_id, accessible.Receive(),
+                            acc_child_id.Receive());
+  if (accessible && acc_child_id.type() == VT_I4)
+    return new AccObject(accessible, V_I4(&acc_child_id));
+  return NULL;
+}
+
+// static
 AccObject* AccObject::CreateFromDispatch(IDispatch* dispatch) {
   if (dispatch) {
     ScopedComPtr<IAccessible> accessible;
     accessible.QueryFrom(dispatch);
     if (accessible)
       return new AccObject(accessible);
   }
   return NULL;
 }
 
@@ skipping 41 matching lines @@
   bool did_select = false;
   ScopedVariant selected;
   if (SUCCEEDED(accessible_->get_accSelection(selected.Receive()))) {
     if (selected.type() != VT_EMPTY)
       did_select = true;
   }
   EXPECT_TRUE(did_select) << "Could not select AccObject: " << GetDescription();
   return did_select;
 }
 
+bool AccObject::SetValue(const std::wstring& value) {
+  ScopedBstr value_bstr(value.c_str());
+  EXPECT_HRESULT_SUCCEEDED(accessible_->put_accValue(child_id_, value_bstr));
+
+  // Double check that the object's value has actually changed. Some objects'
+  // values can not be changed.
+  bool did_set_value = false;
+  std::wstring actual_value = L"-";
+  if (GetValue(&actual_value) && value == actual_value) {
+    did_set_value = true;
+  }
+  EXPECT_TRUE(did_set_value) << "Could not set value for AccObject: "
+                             << GetDescription();
+  return did_set_value;
+}
+
 bool AccObject::GetName(std::wstring* name) {
   DCHECK(name);
   ScopedBstr name_bstr;
   HRESULT result = accessible_->get_accName(child_id_, name_bstr.Receive());
   if (SUCCEEDED(result))
     name->assign(name_bstr, name_bstr.Length());
   return SUCCEEDED(result);
 }
 
 bool AccObject::GetRoleText(std::wstring* role_text) {
@@ skipping 99 matching lines @@
       // possible, since this class operates under the assumption that if the
       // child id is not CHILDID_SELF, the object is a simple element. See the
       // DCHECK in the constructor.
       HRESULT result = accessible_->get_accChild(children[i],
                                                  dispatch.Receive());
       if (result == S_FALSE || result == E_NOINTERFACE) {
         // The object in question really is a simple element. Add it.
         objects.push_back(new AccObject(accessible_, V_I4(&children[i])));
         continue;
       } else if (FAILED(result)) {
-        LOG(ERROR) << "Failed to determine if child id refers to a full "
-                   << "object. Error: " << result;
-        return false;
+        DLOG(WARNING) << "Failed to determine if child id refers to a full "
+                      << "object. Error: " << result << std::endl
+                      << "Parent object: " << WideToUTF8(GetDescription())
+                      << std::endl << "Child ID: " << V_I4(&children[i]);
+        // Disregard this object.
+        continue;
       }
       // The object in question was actually a full object. It is saved in the
       // |dispatch| arg and will be added down below.
     } else if (children[i].type() == VT_DISPATCH) {
       dispatch.Attach(V_DISPATCH(&children[i].Release()));
     } else {
       DLOG(WARNING) << "Unrecognizable child type, omitting from children";
       continue;
     }
 
@@ skipping 144 matching lines @@
     ss << L"Value: '" << value_ << L"'";
   ss << L"]";
   return ss.str();
 }
 
 // Other methods
 bool FindAccObjectInWindow(HWND hwnd, const AccObjectMatcher& matcher,
                            scoped_refptr<AccObject>* object) {
   DCHECK(object);
   EXPECT_TRUE(matcher.FindInWindow(hwnd, object));
-  EXPECT_TRUE(object) << "Element not found for matcher: "
+  EXPECT_TRUE(*object) << "Element not found for matcher: "
         << matcher.GetDescription();
-  if (!object)
+  if (!*object)
     DumpAccessibilityTreeForWindow(hwnd);
   return *object;
 }
 
 void DumpAccessibilityTreeForWindow(HWND hwnd) {
   scoped_refptr<AccObject> object(AccObject::CreateFromWindow(hwnd));
   if (object)
     std::wcout << object->GetTree();
   else
     std::cout << "Could not get IAccessible for window" << std::endl;
 }
 
 bool IsDesktopUnlocked() {
   HDESK desk = ::OpenInputDesktop(0, FALSE, DESKTOP_SWITCHDESKTOP);
   if (desk)
     ::CloseDesktop(desk);
   return desk;
 }
 
 }  // namespace chrome_frame_test