Expose an accessible relation between the main window and active alert.

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 <oleacc.h>
 #include <UIAutomationClient.h>
 
 #include <set>
@@ skipping 171 matching lines @@
       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;
+std::vector<int> NativeViewAccessibilityWin::alert_target_view_storage_ids_;
 
 // static
 NativeViewAccessibility* NativeViewAccessibility::Create(View* view) {
   // Make sure ATL is initialized in this module.
   ui::win::CreateATLModuleIfNeeded();
 
   CComObject<NativeViewAccessibilityWin>* instance = NULL;
   HRESULT hr = CComObject<NativeViewAccessibilityWin>::CreateInstance(
       &instance);
   DCHECK(SUCCEEDED(hr));
   instance->set_view(view);
   instance->AddRef();
   return instance;
 }
 
 NativeViewAccessibilityWin::NativeViewAccessibilityWin()
     : view_(NULL),
       unique_id_(next_unique_id_++) {
 }
 
 NativeViewAccessibilityWin::~NativeViewAccessibilityWin() {
+  RemoveAlertTarget();
 }
 
 void NativeViewAccessibilityWin::NotifyAccessibilityEvent(
     ui::AXEvent event_type) {
   if (!view_)
     return;
 
   ViewStorage* view_storage = ViewStorage::GetInstance();
   HWND hwnd = HWNDForView(view_);
   int view_storage_id = view_storage_ids_[next_view_storage_id_index_];
   if (view_storage_id == 0) {
     view_storage_id = view_storage->CreateStorageID();
     view_storage_ids_[next_view_storage_id_index_] = view_storage_id;
   } else {
     view_storage->RemoveView(view_storage_id);
   }
   view_storage->StoreView(view_storage_id, view_);
 
   // Positive child ids are used for enumerating direct children,
   // negative child ids can be used as unique ids to refer to a specific
   // descendants.  Make index into view_storage_ids_ into a negative child id.
   int child_id =
       base::win::kFirstViewsAccessibilityId - next_view_storage_id_index_;
   ::NotifyWinEvent(MSAAEvent(event_type), hwnd, OBJID_CLIENT, child_id);
   next_view_storage_id_index_ =
       (next_view_storage_id_index_ + 1) % kMaxViewStorageIds;
+
+  // Keep track of views that are a target of an alert event.
+  if (event_type == ui::AX_EVENT_ALERT)
+    AddAlertTarget();
 }
 
 gfx::NativeViewAccessible NativeViewAccessibilityWin::GetNativeObject() {
   return this;
 }
 
 void NativeViewAccessibilityWin::Destroy() {
   view_ = NULL;
   Release();
 }
@@ skipping 609 matching lines @@
   if (!view_)
     return E_FAIL;
 
   if (!window_handle)
     return E_INVALIDARG;
 
   *window_handle = HWNDForView(view_);
   return *window_handle ? S_OK : S_FALSE;
 }
 
+STDMETHODIMP NativeViewAccessibilityWin::get_relationTargetsOfType(
+    BSTR type_bstr,
+    long max_targets,
+    IUnknown ***targets,
+    long *n_targets) {
+  if (!view_)
+    return E_FAIL;
+
+  if (!targets || !n_targets || max_targets <= 0)
+    return E_INVALIDARG;
+
+  *n_targets = 0;
+  base::string16 type(type_bstr);
+  if (type != L"alerts" || view_->parent())
+    return S_OK;
+
+  ViewStorage* view_storage = ViewStorage::GetInstance();
+  for (size_t i = 0; i < alert_target_view_storage_ids_.size(); ++i) {
+    int view_storage_id = alert_target_view_storage_ids_[i];
+    View* view = view_storage->RetrieveView(view_storage_id);
+    if (!view || !view_->Contains(view))
+      continue;
+
+    (*targets)[*n_targets] = view->GetNativeViewAccessible();

[aboxhall, 2014/05/07 15:26:30]

This will put targets in *targets in chronological order, right? Is that what we
want (as opposed to reverse chronological order)? Alternatively, if it is
chronological order we want, do we want to start at max(0,
alert_target_view_storage_ids_.size() - max_targets) to avoid missing the most
recent (and thus presumably most relevant) alerts in favour of older alerts?

[dmazzoni, 2014/05/07 15:31:41]

I hadn't thought about the order. I'm not even sure what we want, I think it may
be more up to the screen reader to decide what to do. I think NV Access was
thinking of announcing something like "There are <n> alerts" if there's more
than 1.

I can see an argument for window order / view order rather than chronological,
too.

I'd prefer to keep the code simple until we know what we want.

+    (*targets)[*n_targets]->AddRef();
+    ++(*n_targets);
+
+    if (*n_targets == max_targets)
+      break;
+  }
+  return S_OK;
+}
+
 //
 // IAccessibleText
 //
 
 STDMETHODIMP NativeViewAccessibilityWin::get_nCharacters(LONG* n_characters) {
   if (!view_)
     return E_FAIL;
 
   if (!n_characters)
     return E_INVALIDARG;
@@ skipping 186 matching lines @@
 
 //
 // IServiceProvider methods.
 //
 
 STDMETHODIMP NativeViewAccessibilityWin::QueryService(
     REFGUID guidService, REFIID riid, void** object) {
   if (!view_)
     return E_FAIL;
 
-  if (riid == IID_IAccessible2)
+  if (riid == IID_IAccessible2 || riid == IID_IAccessible2_2)
     AccessibleWebViewRegistry::GetInstance()->EnableIAccessible2Support();
 
   if (guidService == IID_IAccessible ||
       guidService == IID_IAccessible2 ||
+      guidService == IID_IAccessible2_2 ||
       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.
   if (riid == IID_IAccessibleEx &&
       base::win::GetVersion() >= base::win::VERSION_WIN8) {
@@ skipping 316 matching lines @@
     if (!child_widget->IsVisible())
       continue;
 
     if (widget->GetNativeWindowProperty(kWidgetNativeViewHostKey))
       continue;
 
     result_child_widgets->push_back(child_widget);
   }
 }
 
+void NativeViewAccessibilityWin::AddAlertTarget() {
+  ViewStorage* view_storage = ViewStorage::GetInstance();
+  for (size_t i = 0; i < alert_target_view_storage_ids_.size(); ++i) {
+    int view_storage_id = alert_target_view_storage_ids_[i];
+    View* view = view_storage->RetrieveView(view_storage_id);
+    if (view == view_)

[aboxhall, 2014/05/07 15:26:30]

Similarly, do we want to bump up this view in the alert_target_view_storage_ids_
list if this method gets called again?

+      return;
+  }
+  int view_storage_id = view_storage->CreateStorageID();
+  view_storage->StoreView(view_storage_id, view_);
+  alert_target_view_storage_ids_.push_back(view_storage_id);
+}
+
+void NativeViewAccessibilityWin::RemoveAlertTarget() {
+  ViewStorage* view_storage = ViewStorage::GetInstance();
+  size_t i = 0;
+  while (i < alert_target_view_storage_ids_.size()) {
+    int view_storage_id = alert_target_view_storage_ids_[i];
+    View* view = view_storage->RetrieveView(view_storage_id);
+    if (view == NULL || view == view_) {
+      alert_target_view_storage_ids_.erase(
+          alert_target_view_storage_ids_.begin() + i);

[aboxhall, 2014/05/07 15:26:30]

Why don't we want to increment i in this case?

[dmazzoni, 2014/05/07 15:31:41]

We're erasing the ith element, which should shift everything over and then we
should check the new ith element (which used to be the i+1th element).

Please check my logic. Is there a more foolproof way to do this? I guess if
order doesn't matter I could use a set...

+    } else {
+      ++i;
+    }
+  }
+}
+
 }  // namespace views