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)
+    return E_INVALIDARG;
+
+  *n_targets = 0;
+  *targets = NULL;
+
+  // Only respond to requests for relations of type "alerts" on the
+  // root view.
+  base::string16 type(type_bstr);
+  if (type != L"alerts" || view_->parent())
+    return S_FALSE;
+
+  // Collect all of the alert views that are still valid.
+  std::vector<View*> alert_views;
+  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;
+    alert_views.push_back(view);
+  }
+
+  long count = alert_views.size();
+  if (count == 0)
+    return S_FALSE;
+
+  // Don't return more targets than max_targets - but note that the caller
+  // is allowed to specify max_targets=0 to mean no limit.
+  if (max_targets > 0 && count > max_targets)
+    count = max_targets;
+
+  // Return the number of targets.
+  *n_targets = count;
+
+  // Allocate COM memory for the result array and populate it.
+  if (targets) {

[David Tseng, 2014/05/13 01:34:54]

Didn't you check this above?

[dmazzoni, 2014/05/13 07:38:46]

Done.

+    *targets = static_cast<IUnknown**>(
+        CoTaskMemAlloc(count * sizeof(IUnknown*)));
+    for (long i = 0; i < count; ++i) {
+      (*targets)[i] = alert_views[i]->GetNativeViewAccessible();
+      (*targets)[i]->AddRef();
+    }
+  }
+  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_)
+      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);

[David Tseng, 2014/05/13 01:34:54]

break? (since you're never duplicating ids) on insertion.

[David Tseng, 2014/05/13 13:47:11]

FYI (unresolved comment); not really a big deal since likely very few alerts.

[dmazzoni, 2014/05/13 15:52:44]

Sorry, forgot to respond. I don't want to break because it's a good excuse to
clear out any views that were deleted but whose NativeViewAccessibility hasn't
been dereferenced yet. If we did a break we'd have to handle NULL separately
from (view == view_)

Hope that's okay.

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