Ensure there's no layout pending before accessing WebAXObject from TestRunner.

content/shell/renderer/test_runner/web_ax_object_proxy.cc

 // Copyright 2014 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 "content/shell/renderer/test_runner/web_ax_object_proxy.h"
 
 #include "base/strings/stringprintf.h"
 #include "gin/handle.h"
 #include "third_party/WebKit/public/platform/WebPoint.h"
 #include "third_party/WebKit/public/platform/WebRect.h"
@@ skipping 538 matching lines @@
       .SetMethod("wordStart", &WebAXObjectProxy::WordStart)
       .SetMethod("wordEnd", &WebAXObjectProxy::WordEnd)
       // TODO(hajimehoshi): This is for backward compatibility. Remove them.
       .SetMethod("addNotificationListener",
                  &WebAXObjectProxy::SetNotificationListener)
       .SetMethod("removeNotificationListener",
                  &WebAXObjectProxy::UnsetNotificationListener);
 }
 
 v8::Handle<v8::Object> WebAXObjectProxy::GetChildAtIndex(unsigned index) {
-  return factory_->GetOrCreate(accessibility_object().childAt(index));
+  return factory_->GetOrCreate(accessibility_object_.childAt(index));
 }
 
 bool WebAXObjectProxy::IsRoot() const {
   return false;
 }
 
 bool WebAXObjectProxy::IsEqualToObject(const blink::WebAXObject& other) {
-  return accessibility_object().equals(other);
+  return accessibility_object_.equals(other);
 }
 
 void WebAXObjectProxy::NotificationReceived(
     blink::WebFrame* frame,
     const std::string& notification_name) {
   if (notification_callback_.IsEmpty())
     return;
 
   v8::Handle<v8::Context> context = frame->mainWorldScriptContext();
   if (context.IsEmpty())
@@ skipping 11 matching lines @@
       context->Global(),
       arraysize(argv),
       argv);
 }
 
 void WebAXObjectProxy::Reset()  {
   notification_callback_.Reset();
 }
 
 std::string WebAXObjectProxy::Role() {
-  return GetRole(accessibility_object());
+  accessibility_object_.updateLayoutAndCheckValidity();
+  return GetRole(accessibility_object_);
 }
 
 std::string WebAXObjectProxy::Title() {
-  return GetTitle(accessibility_object());
+  accessibility_object_.updateLayoutAndCheckValidity();
+  return GetTitle(accessibility_object_);
 }
 
 std::string WebAXObjectProxy::Description() {
-  return GetDescription(accessibility_object());
+  accessibility_object_.updateLayoutAndCheckValidity();
+  return GetDescription(accessibility_object_);
 }
 
 std::string WebAXObjectProxy::HelpText() {
-  return GetHelpText(accessibility_object());
+  accessibility_object_.updateLayoutAndCheckValidity();
+  return GetHelpText(accessibility_object_);
 }
 
 std::string WebAXObjectProxy::StringValue() {
-  return GetStringValue(accessibility_object());
+  accessibility_object_.updateLayoutAndCheckValidity();
+  return GetStringValue(accessibility_object_);
 }
 
 int WebAXObjectProxy::X() {
-  accessibility_object_.updateBackingStoreAndCheckValidity();
-  return accessibility_object().boundingBoxRect().x;
+  accessibility_object_.updateLayoutAndCheckValidity();
+  return accessibility_object_.boundingBoxRect().x;
 }
 
 int WebAXObjectProxy::Y() {
-  accessibility_object_.updateBackingStoreAndCheckValidity();
-  return accessibility_object().boundingBoxRect().y;
+  accessibility_object_.updateLayoutAndCheckValidity();
+  return accessibility_object_.boundingBoxRect().y;
 }
 
 int WebAXObjectProxy::Width() {
-  accessibility_object_.updateBackingStoreAndCheckValidity();
-  return accessibility_object().boundingBoxRect().width;
+  accessibility_object_.updateLayoutAndCheckValidity();
+  return accessibility_object_.boundingBoxRect().width;
 }
 
 int WebAXObjectProxy::Height() {
-  accessibility_object_.updateBackingStoreAndCheckValidity();
-  return accessibility_object().boundingBoxRect().height;
+  accessibility_object_.updateLayoutAndCheckValidity();
+  return accessibility_object_.boundingBoxRect().height;
 }
 
 int WebAXObjectProxy::IntValue() {
-  if (accessibility_object().supportsRangeValue())
-    return accessibility_object().valueForRange();
-  else if (accessibility_object().role() == blink::WebAXRoleHeading)
-    return accessibility_object().headingLevel();
+  accessibility_object_.updateLayoutAndCheckValidity();
+  if (accessibility_object_.supportsRangeValue())
+    return accessibility_object_.valueForRange();
+  else if (accessibility_object_.role() == blink::WebAXRoleHeading)
+    return accessibility_object_.headingLevel();
   else
-    return atoi(accessibility_object().stringValue().utf8().data());
+    return atoi(accessibility_object_.stringValue().utf8().data());
 }
 
 int WebAXObjectProxy::MinValue() {
-  return accessibility_object().minValueForRange();
+  accessibility_object_.updateLayoutAndCheckValidity();
+  return accessibility_object_.minValueForRange();
 }
 
 int WebAXObjectProxy::MaxValue() {
-  return accessibility_object().maxValueForRange();
+  accessibility_object_.updateLayoutAndCheckValidity();
+  return accessibility_object_.maxValueForRange();
 }
 
 std::string WebAXObjectProxy::ValueDescription() {
-  return GetValueDescription(accessibility_object());
+  accessibility_object_.updateLayoutAndCheckValidity();
+  return GetValueDescription(accessibility_object_);
 }
 
 int WebAXObjectProxy::ChildrenCount() {
+  accessibility_object_.updateLayoutAndCheckValidity();
   int count = 1; // Root object always has only one child, the WebView.
   if (!IsRoot())
-    count = accessibility_object().childCount();
+    count = accessibility_object_.childCount();
   return count;
 }
 
 int WebAXObjectProxy::InsertionPointLineNumber() {
-  if (!accessibility_object().isFocused())
+  accessibility_object_.updateLayoutAndCheckValidity();
+  if (!accessibility_object_.isFocused())
     return -1;
-  return accessibility_object().selectionEndLineNumber();
+  return accessibility_object_.selectionEndLineNumber();
 }
 
 std::string WebAXObjectProxy::SelectedTextRange() {
-  unsigned selection_start = accessibility_object().selectionStart();
-  unsigned selection_end = accessibility_object().selectionEnd();
+  accessibility_object_.updateLayoutAndCheckValidity();
+  unsigned selection_start = accessibility_object_.selectionStart();
+  unsigned selection_end = accessibility_object_.selectionEnd();
   return base::StringPrintf("{%d, %d}",
                             selection_start, selection_end - selection_start);
 }
 
 bool WebAXObjectProxy::IsEnabled() {
-  return accessibility_object().isEnabled();
+  accessibility_object_.updateLayoutAndCheckValidity();
+  return accessibility_object_.isEnabled();
 }
 
 bool WebAXObjectProxy::IsRequired() {
-  return accessibility_object().isRequired();
+  accessibility_object_.updateLayoutAndCheckValidity();
+  return accessibility_object_.isRequired();
 }
 
 bool WebAXObjectProxy::IsFocused() {
-  return accessibility_object().isFocused();
+  accessibility_object_.updateLayoutAndCheckValidity();
+  return accessibility_object_.isFocused();
 }
 
 bool WebAXObjectProxy::IsFocusable() {
-  return accessibility_object().canSetFocusAttribute();
+  accessibility_object_.updateLayoutAndCheckValidity();
+  return accessibility_object_.canSetFocusAttribute();
 }
 
 bool WebAXObjectProxy::IsSelected() {
-  return accessibility_object().isSelected();
+  accessibility_object_.updateLayoutAndCheckValidity();
+  return accessibility_object_.isSelected();
 }
 
 bool WebAXObjectProxy::IsSelectable() {
-  return accessibility_object().canSetSelectedAttribute();
+  accessibility_object_.updateLayoutAndCheckValidity();
+  return accessibility_object_.canSetSelectedAttribute();
 }
 
 bool WebAXObjectProxy::IsMultiSelectable() {
-  return accessibility_object().isMultiSelectable();
+  accessibility_object_.updateLayoutAndCheckValidity();
+  return accessibility_object_.isMultiSelectable();
 }
 
 bool WebAXObjectProxy::IsSelectedOptionActive() {
-  return accessibility_object().isSelectedOptionActive();
+  accessibility_object_.updateLayoutAndCheckValidity();
+  return accessibility_object_.isSelectedOptionActive();
 }
 
 bool WebAXObjectProxy::IsExpanded() {
-  return !accessibility_object().isCollapsed();
+  accessibility_object_.updateLayoutAndCheckValidity();
+  return !accessibility_object_.isCollapsed();
 }
 
 bool WebAXObjectProxy::IsChecked() {
-  return accessibility_object().isChecked();
+  accessibility_object_.updateLayoutAndCheckValidity();
+  return accessibility_object_.isChecked();
 }
 
 bool WebAXObjectProxy::IsVisible() {
-  return accessibility_object().isVisible();
+  accessibility_object_.updateLayoutAndCheckValidity();
+  return accessibility_object_.isVisible();
 }
 
 bool WebAXObjectProxy::IsOffScreen() {
-  return accessibility_object().isOffScreen();
+  accessibility_object_.updateLayoutAndCheckValidity();
+  return accessibility_object_.isOffScreen();
 }
 
 bool WebAXObjectProxy::IsCollapsed() {
-  return accessibility_object().isCollapsed();
+  accessibility_object_.updateLayoutAndCheckValidity();
+  return accessibility_object_.isCollapsed();
 }
 
 bool WebAXObjectProxy::HasPopup() {
-  return accessibility_object().ariaHasPopup();
+  accessibility_object_.updateLayoutAndCheckValidity();
+  return accessibility_object_.ariaHasPopup();
 }
 
 bool WebAXObjectProxy::IsValid() {
-  return !accessibility_object().isDetached();
+  accessibility_object_.updateLayoutAndCheckValidity();
+  return !accessibility_object_.isDetached();
 }
 
 bool WebAXObjectProxy::IsReadOnly() {
-  return accessibility_object().isReadOnly();
+  accessibility_object_.updateLayoutAndCheckValidity();
+  return accessibility_object_.isReadOnly();
 }
 
 std::string WebAXObjectProxy::Orientation() {
-  return GetOrientation(accessibility_object());
+  accessibility_object_.updateLayoutAndCheckValidity();
+  return GetOrientation(accessibility_object_);
 }
 
 int WebAXObjectProxy::ClickPointX() {
-  return accessibility_object().clickPoint().x;
+  accessibility_object_.updateLayoutAndCheckValidity();
+  return accessibility_object_.clickPoint().x;
 }
 
 int WebAXObjectProxy::ClickPointY() {
-  return accessibility_object().clickPoint().y;
+  accessibility_object_.updateLayoutAndCheckValidity();
+  return accessibility_object_.clickPoint().y;
 }
 
 int32_t WebAXObjectProxy::RowCount() {
-  return static_cast<int32_t>(accessibility_object().rowCount());
+  accessibility_object_.updateLayoutAndCheckValidity();
+  return static_cast<int32_t>(accessibility_object_.rowCount());
 }
 
 int32_t WebAXObjectProxy::ColumnCount() {
-  return static_cast<int32_t>(accessibility_object().columnCount());
+  accessibility_object_.updateLayoutAndCheckValidity();
+  return static_cast<int32_t>(accessibility_object_.columnCount());
 }
 
 bool WebAXObjectProxy::IsClickable() {
-  return accessibility_object().isClickable();
+  accessibility_object_.updateLayoutAndCheckValidity();
+  return accessibility_object_.isClickable();
 }
 
 std::string WebAXObjectProxy::AllAttributes() {
-  return GetAttributes(accessibility_object());
+  accessibility_object_.updateLayoutAndCheckValidity();
+  return GetAttributes(accessibility_object_);
 }
 
 std::string WebAXObjectProxy::AttributesOfChildren() {
+  accessibility_object_.updateLayoutAndCheckValidity();
   AttributesCollector collector;
-  unsigned size = accessibility_object().childCount();
+  unsigned size = accessibility_object_.childCount();
   for (unsigned i = 0; i < size; ++i)
-    collector.CollectAttributes(accessibility_object().childAt(i));
+    collector.CollectAttributes(accessibility_object_.childAt(i));
   return collector.attributes();
 }
 
 int WebAXObjectProxy::LineForIndex(int index) {
+  accessibility_object_.updateLayoutAndCheckValidity();
   blink::WebVector<int> line_breaks;
-  accessibility_object().lineBreaks(line_breaks);
+  accessibility_object_.lineBreaks(line_breaks);
   int line = 0;
   int vector_size = static_cast<int>(line_breaks.size());
   while (line < vector_size && line_breaks[line] <= index)
     line++;
   return line;
 }
 
 std::string WebAXObjectProxy::BoundsForRange(int start, int end) {
-  if (accessibility_object().role() != blink::WebAXRoleStaticText)
+  accessibility_object_.updateLayoutAndCheckValidity();
+  if (accessibility_object_.role() != blink::WebAXRoleStaticText)
     return std::string();
 
-  if (!accessibility_object_.updateBackingStoreAndCheckValidity())
+  if (!accessibility_object_.updateLayoutAndCheckValidity())
     return std::string();
 
   int len = end - start;
 
   // Get the bounds for each character and union them into one large rectangle.
   // This is just for testing so it doesn't need to be efficient.
-  blink::WebRect bounds = BoundsForCharacter(accessibility_object(), start);
+  blink::WebRect bounds = BoundsForCharacter(accessibility_object_, start);
   for (int i = 1; i < len; i++) {
-    blink::WebRect next = BoundsForCharacter(accessibility_object(), start + i);
+    blink::WebRect next = BoundsForCharacter(accessibility_object_, start + i);
     int right = std::max(bounds.x + bounds.width, next.x + next.width);
     int bottom = std::max(bounds.y + bounds.height, next.y + next.height);
     bounds.x = std::min(bounds.x, next.x);
     bounds.y = std::min(bounds.y, next.y);
     bounds.width = right - bounds.x;
     bounds.height = bottom - bounds.y;
   }
 
   return base::StringPrintf("{x: %d, y: %d, width: %d, height: %d}",
                             bounds.x, bounds.y, bounds.width, bounds.height);
 }
 
 v8::Handle<v8::Object> WebAXObjectProxy::ChildAtIndex(int index) {
+  accessibility_object_.updateLayoutAndCheckValidity();
   return GetChildAtIndex(index);
 }
 
 v8::Handle<v8::Object> WebAXObjectProxy::ElementAtPoint(int x, int y) {
+  accessibility_object_.updateLayoutAndCheckValidity();
   blink::WebPoint point(x, y);
-  blink::WebAXObject obj = accessibility_object().hitTest(point);
+  blink::WebAXObject obj = accessibility_object_.hitTest(point);
   if (obj.isNull())
     return v8::Handle<v8::Object>();
 
   return factory_->GetOrCreate(obj);
 }
 
 v8::Handle<v8::Object> WebAXObjectProxy::TableHeader() {
-  blink::WebAXObject obj = accessibility_object().headerContainerObject();
+  accessibility_object_.updateLayoutAndCheckValidity();
+  blink::WebAXObject obj = accessibility_object_.headerContainerObject();
   if (obj.isNull())
     return v8::Handle<v8::Object>();
 
   return factory_->GetOrCreate(obj);
 }
 
 std::string WebAXObjectProxy::RowIndexRange() {
-  unsigned row_index = accessibility_object().cellRowIndex();
-  unsigned row_span = accessibility_object().cellRowSpan();
+  accessibility_object_.updateLayoutAndCheckValidity();
+  unsigned row_index = accessibility_object_.cellRowIndex();
+  unsigned row_span = accessibility_object_.cellRowSpan();
   return base::StringPrintf("{%d, %d}", row_index, row_span);
 }
 
 std::string WebAXObjectProxy::ColumnIndexRange() {
-  unsigned column_index = accessibility_object().cellColumnIndex();
-  unsigned column_span = accessibility_object().cellColumnSpan();
+  accessibility_object_.updateLayoutAndCheckValidity();
+  unsigned column_index = accessibility_object_.cellColumnIndex();
+  unsigned column_span = accessibility_object_.cellColumnSpan();
   return base::StringPrintf("{%d, %d}", column_index, column_span);
 }
 
 v8::Handle<v8::Object> WebAXObjectProxy::CellForColumnAndRow(
     int column, int row) {
+  accessibility_object_.updateLayoutAndCheckValidity();
   blink::WebAXObject obj =
-      accessibility_object().cellForColumnAndRow(column, row);
+      accessibility_object_.cellForColumnAndRow(column, row);
   if (obj.isNull())
     return v8::Handle<v8::Object>();
 
   return factory_->GetOrCreate(obj);
 }
 
 v8::Handle<v8::Object> WebAXObjectProxy::TitleUIElement() {
-  blink::WebAXObject obj = accessibility_object().titleUIElement();
+  accessibility_object_.updateLayoutAndCheckValidity();
+  blink::WebAXObject obj = accessibility_object_.titleUIElement();
   if (obj.isNull())
     return v8::Handle<v8::Object>();
 
   return factory_->GetOrCreate(obj);
 }
 
 void WebAXObjectProxy::SetSelectedTextRange(int selection_start,
                                             int length) {
-  accessibility_object().setSelectedTextRange(selection_start,
+  accessibility_object_.updateLayoutAndCheckValidity();
+  accessibility_object_.setSelectedTextRange(selection_start,
                                               selection_start + length);
 }
 
 bool WebAXObjectProxy::IsAttributeSettable(const std::string& attribute) {
+  accessibility_object_.updateLayoutAndCheckValidity();
   bool settable = false;
   if (attribute == "AXValue")
-    settable = accessibility_object().canSetValueAttribute();
+    settable = accessibility_object_.canSetValueAttribute();
   return settable;
 }
 
 bool WebAXObjectProxy::IsPressActionSupported() {
-  return accessibility_object().canPress();
+  accessibility_object_.updateLayoutAndCheckValidity();
+  return accessibility_object_.canPress();
 }
 
 bool WebAXObjectProxy::IsIncrementActionSupported() {
-  return accessibility_object().canIncrement();
+  accessibility_object_.updateLayoutAndCheckValidity();
+  return accessibility_object_.canIncrement();
 }
 
 bool WebAXObjectProxy::IsDecrementActionSupported() {
-  return accessibility_object().canDecrement();
+  accessibility_object_.updateLayoutAndCheckValidity();
+  return accessibility_object_.canDecrement();
 }
 
 v8::Handle<v8::Object> WebAXObjectProxy::ParentElement() {
-  blink::WebAXObject parent_object = accessibility_object().parentObject();
+  accessibility_object_.updateLayoutAndCheckValidity();
+  blink::WebAXObject parent_object = accessibility_object_.parentObject();
   while (parent_object.accessibilityIsIgnored())
     parent_object = parent_object.parentObject();
   return factory_->GetOrCreate(parent_object);
 }
 
 void WebAXObjectProxy::Increment() {
-  accessibility_object().increment();
+  accessibility_object_.updateLayoutAndCheckValidity();
+  accessibility_object_.increment();
 }
 
 void WebAXObjectProxy::Decrement() {
-  accessibility_object().decrement();
+  accessibility_object_.updateLayoutAndCheckValidity();
+  accessibility_object_.decrement();
 }
 
 void WebAXObjectProxy::ShowMenu() {
 }
 
 void WebAXObjectProxy::Press() {
-  accessibility_object().press();
+  accessibility_object_.updateLayoutAndCheckValidity();
+  accessibility_object_.press();
 }
 
 bool WebAXObjectProxy::IsEqual(v8::Handle<v8::Object> proxy) {
   WebAXObjectProxy* unwrapped_proxy = NULL;
   if (!gin::ConvertFromV8(blink::mainThreadIsolate(), proxy, &unwrapped_proxy))
     return false;
   return unwrapped_proxy->IsEqualToObject(accessibility_object_);
 }
 
 void WebAXObjectProxy::SetNotificationListener(
     v8::Handle<v8::Function> callback) {
   v8::Isolate* isolate = blink::mainThreadIsolate();
   notification_callback_.Reset(isolate, callback);
 }
 
 void WebAXObjectProxy::UnsetNotificationListener() {
   notification_callback_.Reset();
 }
 
 void WebAXObjectProxy::TakeFocus() {
-  accessibility_object().setFocused(true);
+  accessibility_object_.updateLayoutAndCheckValidity();
+  accessibility_object_.setFocused(true);
 }
 
 void WebAXObjectProxy::ScrollToMakeVisible() {
-  accessibility_object().scrollToMakeVisible();
+  accessibility_object_.updateLayoutAndCheckValidity();
+  accessibility_object_.scrollToMakeVisible();
 }
 
 void WebAXObjectProxy::ScrollToMakeVisibleWithSubFocus(int x, int y,
                                                        int width, int height) {
-  accessibility_object().scrollToMakeVisibleWithSubFocus(
+  accessibility_object_.updateLayoutAndCheckValidity();
+  accessibility_object_.scrollToMakeVisibleWithSubFocus(
       blink::WebRect(x, y, width, height));
 }
 
 void WebAXObjectProxy::ScrollToGlobalPoint(int x, int y) {
-  accessibility_object().scrollToGlobalPoint(blink::WebPoint(x, y));
+  accessibility_object_.updateLayoutAndCheckValidity();
+  accessibility_object_.scrollToGlobalPoint(blink::WebPoint(x, y));
 }
 
 int WebAXObjectProxy::WordStart(int character_index) {
-  if (accessibility_object().role() != blink::WebAXRoleStaticText)
+  accessibility_object_.updateLayoutAndCheckValidity();
+  if (accessibility_object_.role() != blink::WebAXRoleStaticText)
     return -1;
 
   int word_start, word_end;
-  GetBoundariesForOneWord(accessibility_object(), character_index,
+  GetBoundariesForOneWord(accessibility_object_, character_index,
                           word_start, word_end);
   return word_start;
 }
 
 int WebAXObjectProxy::WordEnd(int character_index) {
-  if (accessibility_object().role() != blink::WebAXRoleStaticText)
+  accessibility_object_.updateLayoutAndCheckValidity();
+  if (accessibility_object_.role() != blink::WebAXRoleStaticText)
     return -1;
 
   int word_start, word_end;
-  GetBoundariesForOneWord(accessibility_object(), character_index,
+  GetBoundariesForOneWord(accessibility_object_, character_index,
                           word_start, word_end);
   return word_end;
 }
 
 RootWebAXObjectProxy::RootWebAXObjectProxy(
     const blink::WebAXObject &object, Factory *factory)
     : WebAXObjectProxy(object, factory) {
 }
 
 v8::Handle<v8::Object> RootWebAXObjectProxy::GetChildAtIndex(unsigned index) {
@@ skipping 63 matching lines @@
   v8::Handle<v8::Value> value_handle = gin::CreateHandle(
       isolate, new RootWebAXObjectProxy(object, this)).ToV8();
   if (value_handle.IsEmpty())
     return v8::Handle<v8::Object>();
   v8::Handle<v8::Object> handle = value_handle->ToObject();
   elements_.Append(handle);
   return handle;
 }
 
 }  // namespace content