Use IAccessible2 to detect screen reader in Win Aura

ui/views/accessibility/native_view_accessibility_win.cc

 // Copyright (c) 2012 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 "ui/views/accessibility/native_view_accessibility_win.h"
 
 #include <UIAutomationClient.h>
 #include <oleacc.h>
 
 #include <set>
 #include <vector>
 
 #include "base/memory/singleton.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/win/scoped_comptr.h"
 #include "base/win/windows_version.h"
 #include "third_party/iaccessible2/ia2_api_all.h"
 #include "ui/base/accessibility/accessible_text_utils.h"
 #include "ui/base/accessibility/accessible_view_state.h"
 #include "ui/base/win/accessibility_ids_win.h"
 #include "ui/base/win/accessibility_misc_utils.h"
 #include "ui/base/win/atl_module.h"
 #include "ui/views/controls/button/custom_button.h"
 #include "ui/views/focus/focus_manager.h"
 #include "ui/views/focus/view_storage.h"
@@ skipping 12 matching lines @@
   void RegisterWebView(View* web_view);
 
   void UnregisterWebView(View* web_view);
 
   // Given the view that received the request for the accessible
   // id in |top_view|, and the child id requested, return the native
   // accessible object with that child id from one of the WebViews in
   // |top_view|'s view hierarchy, if any.
   IAccessible* GetAccessibleFromWebView(View* top_view, long child_id);
 
+  // The system uses IAccessible APIs for many purposes, but only
+  // assistive technology like screen readers uses IAccessible2.
+  // Call this method to note that the IAccessible2 interface was queried and
+  // that WebViews should be proactively notified that this interface will be
+  // used. If this is enabled for the first time, this will explicitly call
+  // QueryService with an argument of IAccessible2 on all WebViews, otherwise
+  // it will just do it from now on.
+  void EnableIAccessible2Support();
+
  private:
   friend struct DefaultSingletonTraits<AccessibleWebViewRegistry>;
   AccessibleWebViewRegistry();
   ~AccessibleWebViewRegistry() {}
 
   IAccessible* AccessibleObjectFromChildId(View* web_view, long child_id);
 
+  void QueryIAccessible2Interface(View* web_view);
+
   // Set of all web views. We check whether each one is contained in a
   // top view dynamically rather than keeping track of a map.
   std::set<View*> web_views_;
 
   // The most recent top view used in a call to GetAccessibleFromWebView.
   View* last_top_view_;
 
   // The most recent web view where an accessible object was found,
   // corresponding to |last_top_view_|.
   View* last_web_view_;
 
+  // If IAccessible2 support is enabled, we query the IAccessible2 interface
+  // of WebViews proactively when they're registered, so that they are
+  // aware that they need to support this interface.
+  bool iaccessible2_support_enabled_;
+
   DISALLOW_COPY_AND_ASSIGN(AccessibleWebViewRegistry);
 };
 
 AccessibleWebViewRegistry::AccessibleWebViewRegistry()
     : last_top_view_(NULL),
-      last_web_view_(NULL) {
+      last_web_view_(NULL),
+      iaccessible2_support_enabled_(false) {
 }
 
 AccessibleWebViewRegistry* AccessibleWebViewRegistry::GetInstance() {
   return Singleton<AccessibleWebViewRegistry>::get();
 }
 
 void AccessibleWebViewRegistry::RegisterWebView(View* web_view) {
   DCHECK(web_views_.find(web_view) == web_views_.end());
   web_views_.insert(web_view);
+
+  if (iaccessible2_support_enabled_)
+    QueryIAccessible2Interface(web_view);
 }
 
 void AccessibleWebViewRegistry::UnregisterWebView(View* web_view) {
   DCHECK(web_views_.find(web_view) != web_views_.end());
   web_views_.erase(web_view);
   if (last_web_view_ == web_view) {
     last_top_view_ = NULL;
     last_web_view_ = NULL;
   }
 }
@@ skipping 23 matching lines @@
     if (accessible) {
       last_top_view_ = top_view;
       last_web_view_ = web_view;
       return accessible;
     }
   }
 
   return NULL;
 }
 
+void AccessibleWebViewRegistry::EnableIAccessible2Support() {
+  if (iaccessible2_support_enabled_)
+    return;
+  iaccessible2_support_enabled_ = true;
+  for (std::set<View*>::iterator iter = web_views_.begin();
+       iter != web_views_.end(); ++iter) {
+    QueryIAccessible2Interface(*iter);
+  }
+}
+
 IAccessible* AccessibleWebViewRegistry::AccessibleObjectFromChildId(
     View* web_view,
     long child_id) {
   IAccessible* web_view_accessible = web_view->GetNativeViewAccessible();
   if (web_view_accessible == NULL)
     return NULL;
 
   VARIANT var_child;
   var_child.vt = VT_I4;
   var_child.lVal = child_id;
   IAccessible* result = NULL;
   if (S_OK == web_view_accessible->get_accChild(
       var_child, reinterpret_cast<IDispatch**>(&result))) {
     return result;
   }
 
   return NULL;
 }
 
+void AccessibleWebViewRegistry::QueryIAccessible2Interface(View* web_view) {
+  IAccessible* web_view_accessible = web_view->GetNativeViewAccessible();
+  if (!web_view_accessible)
+    return;
+
+  base::win::ScopedComPtr<IServiceProvider> service_provider;
+  if (S_OK != web_view_accessible->QueryInterface(service_provider.Receive()))
+    return;
+  base::win::ScopedComPtr<IAccessible2> iaccessible2;
+  service_provider->QueryService(
+      IID_IAccessible, IID_IAccessible2,
+      reinterpret_cast<void**>(iaccessible2.Receive()));
+}
+
 }  // anonymous namespace
 
 // static
 long NativeViewAccessibilityWin::next_unique_id_ = 1;
 int NativeViewAccessibilityWin::view_storage_ids_[kMaxViewStorageIds] = {0};
 int NativeViewAccessibilityWin::next_view_storage_id_index_ = 0;
 
 // static
 NativeViewAccessibility* NativeViewAccessibility::Create(View* view) {
   // Make sure ATL is initialized in this module.
@@ skipping 867 matching lines @@
 
 //
 // IServiceProvider methods.
 //
 
 STDMETHODIMP NativeViewAccessibilityWin::QueryService(
     REFGUID guidService, REFIID riid, void** object) {
   if (!view_)
     return E_FAIL;
 
+  if (riid == IID_IAccessible2)
+    AccessibleWebViewRegistry::GetInstance()->EnableIAccessible2Support();
+
   if (guidService == IID_IAccessible ||
       guidService == IID_IAccessible2 ||
       guidService == IID_IAccessibleText)  {
     return QueryInterface(riid, object);
   }
 
   // We only support the IAccessibleEx interface on Windows 8 and above. This
   // is needed for the On screen Keyboard to show up in metro mode, when the
   // user taps an editable region in the window.
   // All methods in the IAccessibleEx interface are unimplemented.
@@ skipping 318 matching lines @@
       continue;
 
     if (widget->GetNativeWindowProperty(kWidgetNativeViewHostKey))
       continue;
 
     result_child_widgets->push_back(child_widget);
   }
 }
 
 }  // namespace views