Accessibility information from the renderer was not being returned to tools l...

views/accessibility/view_accessibility.cc

 // Copyright (c) 2006-2008 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 "views/accessibility/view_accessibility.h"
 
 #include "views/accessibility/view_accessibility_wrapper.h"
 #include "views/widget/widget.h"
 
+const wchar_t kViewsUninitializeAccessibilityInstance[] =
+  L"Views_Uninitialize_AccessibilityInstance";
+
+const wchar_t kViewsNativeHostPropForAccessibility[] =
+  L"Views_NativeViewHostHWNDForAccessibility";
+
+
 HRESULT ViewAccessibility::Initialize(views::View* view) {
   if (!view) {
     return E_INVALIDARG;
   }
 
   view_ = view;
   return S_OK;
 }
 
 // TODO(klink): Handle case where child View is not contained by parent.
 STDMETHODIMP ViewAccessibility::accHitTest(LONG x_left, LONG y_top,
                                            VARIANT* child) {
   if (!child) {
     return E_INVALIDARG;
   }
 
+  if (!view_) {
+    return E_FAIL;
+  }
+
   gfx::Point pt(x_left, y_top);
   views::View::ConvertPointToView(NULL, view_, &pt);
 
   if (!view_->HitTest(pt)) {
     // If containing parent is not hit, return with failure.
     child->vt = VT_EMPTY;
     return S_FALSE;
   }
 
   int child_count = view_->GetChildViewCount();
@@ skipping 39 matching lines @@
   return S_OK;
 }
 
 STDMETHODIMP ViewAccessibility::accLocation(LONG* x_left, LONG* y_top,
                                             LONG* width, LONG* height,
                                             VARIANT var_id) {
   if (var_id.vt != VT_I4 || !x_left || !y_top || !width || !height) {
     return E_INVALIDARG;
   }
 
+  if (!view_) {
+    return E_FAIL;
+  }
+
   gfx::Rect view_bounds;
   // Retrieving the parent View to be used for converting from view-to-screen
   // coordinates.
   views::View* parent = view_->GetParent();
 
   if (parent == NULL) {
     // If no parent, remain within the same View.
     parent = view_;
   }
 
@@ skipping 24 matching lines @@
   }
   return S_OK;
 }
 
 STDMETHODIMP ViewAccessibility::accNavigate(LONG nav_dir, VARIANT start,
                                             VARIANT* end) {
   if (start.vt != VT_I4 || !end) {
     return E_INVALIDARG;
   }
 
+  if (!view_) {
+    return E_FAIL;
+  }
+
   switch (nav_dir) {
     case NAVDIR_FIRSTCHILD:
     case NAVDIR_LASTCHILD: {
       if (start.lVal != CHILDID_SELF) {
         // Start of navigation must be on the View itself.
         return E_INVALIDARG;
       } else if (view_->GetChildViewCount() == 0) {
         // No children found.
         return S_FALSE;
       }
@@ skipping 35 matching lines @@
       views::View* parent = view_->GetParent();
       if (!parent) {
         return E_FAIL;
       }
 
       if (start.lVal == CHILDID_SELF) {
         int view_index = parent->GetChildIndex(view_);
         // Check navigation bounds, adjusting for View child indexing (MSAA
         // child indexing starts with 1, whereas View indexing starts with 0).
         if (!IsValidNav(nav_dir, view_index, -1,
-                        parent->GetChildViewCount())) {
+                        parent->GetChildViewCount() - 1)) {
           // Navigation attempted to go out-of-bounds.
           end->vt = VT_EMPTY;
           return S_FALSE;
         } else {
           if (IsNavDirNext(nav_dir)) {
             view_index += 1;
           } else {
             view_index -=1;
           }
         }
@@ skipping 59 matching lines @@
                                              IDispatch** disp_child) {
   if (var_child.vt != VT_I4 || !disp_child) {
     return E_INVALIDARG;
   }
 
   // If var_child is the parent, remain with the same IDispatch.
   if (var_child.lVal == CHILDID_SELF) {
     return S_OK;
   }
 
+  if (!view_) {
+    return E_FAIL;
+  }
+
   views::View* child_view = NULL;
   bool get_iaccessible = false;
 
   // Check to see if child is out-of-bounds.
   if (IsValidChild((var_child.lVal - 1), view_)) {
     child_view = view_->GetChildViewAt(var_child.lVal - 1);
   } else {
     // Child is located elsewhere in the hierarchy, get ID and adjust for MSAA.
     child_view = view_->GetViewByID(static_cast<int>(var_child.lVal));
     get_iaccessible = true;
@@ skipping 12 matching lines @@
         GetInstance(IID_IAccessible,
                     reinterpret_cast<void**>(disp_child)) == S_OK) {
       // Increment the reference count for the retrieved interface.
       (*disp_child)->AddRef();
       return S_OK;
     } else {
       // No interface, return failure.
       return E_NOINTERFACE;
     }
   } else {
+    if (child_view->GetClassName() == views::NativeViewHost::kViewClassName) {
+      views::NativeViewHost* native_host =
+          static_cast<views::NativeViewHost*>(child_view);
+      if (GetNativeIAccessibleInterface(native_host, disp_child) == S_OK)
+        return S_OK;
+    }
     // When at a leaf, children are handled by the parent object.
     *disp_child = NULL;
     return S_FALSE;
   }
 }
 
 STDMETHODIMP ViewAccessibility::get_accChildCount(LONG* child_count) {
   if (!child_count || !view_) {
     return E_INVALIDARG;
   }
 
+  if (!view_) {
+    return E_FAIL;
+  }
+
   *child_count = view_->GetChildViewCount();
   return S_OK;
 }
 
 STDMETHODIMP ViewAccessibility::get_accDefaultAction(VARIANT var_id,
                                                      BSTR* def_action) {
   if (var_id.vt != VT_I4 || !def_action) {
     return E_INVALIDARG;
   }
 
+  if (!view_) {
+    return E_FAIL;
+  }
+
   std::wstring temp_action;
 
   if (var_id.lVal == CHILDID_SELF) {
     view_->GetAccessibleDefaultAction(&temp_action);
   } else {
     if (!IsValidChild((var_id.lVal - 1), view_)) {
       return E_INVALIDARG;
     }
     view_->GetChildViewAt(var_id.lVal - 1)->
         GetAccessibleDefaultAction(&temp_action);
@@ skipping 29 matching lines @@
   }
 
   return S_OK;
 }
 
 STDMETHODIMP ViewAccessibility::get_accFocus(VARIANT* focus_child) {
   if (!focus_child) {
     return E_INVALIDARG;
   }
 
+  if (!view_) {
+    return E_FAIL;
+  }
+
   if (view_->GetChildViewCount() == 0 && view_->HasFocus()) {
     // Parent view has focus.
     focus_child->vt = VT_I4;
     focus_child->lVal = CHILDID_SELF;
   } else {
     bool has_focus = false;
     int child_count = view_->GetChildViewCount();
     // Search for child view with focus.
     for (int child_id = 0; child_id < child_count; ++child_id) {
       if (view_->GetChildViewAt(child_id)->HasFocus()) {
@@ skipping 18 matching lines @@
 
   return S_OK;
 }
 
 STDMETHODIMP ViewAccessibility::get_accKeyboardShortcut(VARIANT var_id,
                                                         BSTR* acc_key) {
   if (var_id.vt != VT_I4 || !acc_key) {
     return E_INVALIDARG;
   }
 
+  if (!view_) {
+    return E_FAIL;
+  }
+
   std::wstring temp_key;
 
   if (var_id.lVal == CHILDID_SELF) {
     view_->GetAccessibleKeyboardShortcut(&temp_key);
   } else {
     if (!IsValidChild((var_id.lVal - 1), view_)) {
       return E_INVALIDARG;
     }
     view_->GetChildViewAt(var_id.lVal - 1)->
         GetAccessibleKeyboardShortcut(&temp_key);
   }
   if (!temp_key.empty()) {
     *acc_key = SysAllocString(temp_key.c_str());
   } else {
     return S_FALSE;
   }
 
   return S_OK;
 }
 
 STDMETHODIMP ViewAccessibility::get_accName(VARIANT var_id, BSTR* name) {
   if (var_id.vt != VT_I4 || !name) {
     return E_INVALIDARG;
   }
 
+  if (!view_) {
+    return E_FAIL;
+  }
+
   std::wstring temp_name;
 
   if (var_id.lVal == CHILDID_SELF) {
     // Retrieve the parent view's name.
     view_->GetAccessibleName(&temp_name);
   } else {
     if (!IsValidChild((var_id.lVal - 1), view_)) {
       return E_INVALIDARG;
     }
     // Retrieve the child view's name.
     view_->GetChildViewAt(var_id.lVal - 1)->GetAccessibleName(&temp_name);
   }
   if (!temp_name.empty()) {
     // Return name retrieved.
     *name = SysAllocString(temp_name.c_str());
   } else {
     // If view has no name, return S_FALSE.
     return S_FALSE;
   }
 
   return S_OK;
 }
 
 STDMETHODIMP ViewAccessibility::get_accParent(IDispatch** disp_parent) {
   if (!disp_parent) {
     return E_INVALIDARG;
   }
 
+  if (!view_) {
+    return E_FAIL;
+  }
+
   views::View* parent_view = view_->GetParent();
 
   if (!parent_view) {
     // This function can get called during teardown of WidetWin so we
     // should bail out if we fail to get the HWND.
     if (!view_->GetWidget() || !view_->GetWidget()->GetNativeView()) {
       *disp_parent = NULL;
       return S_FALSE;
     }
 
@@ skipping 231 matching lines @@
   }
   return E_NOTIMPL;
 }
 
 STDMETHODIMP ViewAccessibility::put_accName(VARIANT var_id, BSTR put_name) {
   // Deprecated.
   return E_NOTIMPL;
 }
 
 STDMETHODIMP ViewAccessibility::put_accValue(VARIANT var_id, BSTR put_val) {
+  if (V_VT(&var_id) == VT_BSTR) {
+    if (!lstrcmpi(var_id.bstrVal, kViewsUninitializeAccessibilityInstance)) {
+      view_ = NULL;
+      return S_OK;
+    }
+  }
   // Deprecated.
   return E_NOTIMPL;
 }
+
+HRESULT ViewAccessibility::GetNativeIAccessibleInterface(
+    views::NativeViewHost* native_host, IDispatch** disp_child) {
+  if (!native_host || !disp_child) {
+    return E_INVALIDARG;
+  }
+
+  HWND render_view_window =
+      static_cast<HWND>(GetProp(native_host->native_view(),
+                                kViewsNativeHostPropForAccessibility));
+
+  if (IsWindow(render_view_window)) {
+    LRESULT ret = SendMessage(render_view_window, WM_GETOBJECT, 0,
+                              OBJID_CLIENT);
+    return ObjectFromLresult(ret, IID_IDispatch, 0,
+                             reinterpret_cast<void**>(disp_child));
+  }
+
+  return E_FAIL;
+}