ui/views/accessibility/native_view_accessibility_win.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ui/views/accessibility/native_view_accessibility_win.h"
   6
   7 #include <oleacc.h>
   8 #include <UIAutomationClient.h>
   9
  10 #include <set>
  11 #include <vector>
  12
  13 #include "base/memory/singleton.h"
  14 #include "base/strings/utf_string_conversions.h"
  15 #include "base/win/scoped_comptr.h"
  16 #include "base/win/windows_version.h"
  17 #include "third_party/iaccessible2/ia2_api_all.h"
  18 #include "ui/accessibility/ax_enums.h"
  19 #include "ui/accessibility/ax_text_utils.h"
  20 #include "ui/accessibility/ax_view_state.h"
  21 #include "ui/base/win/accessibility_ids_win.h"
  22 #include "ui/base/win/accessibility_misc_utils.h"
  23 #include "ui/base/win/atl_module.h"
  24 #include "ui/views/controls/button/custom_button.h"
  25 #include "ui/views/focus/focus_manager.h"
  26 #include "ui/views/focus/view_storage.h"
  27 #include "ui/views/widget/widget.h"
  28 #include "ui/views/win/hwnd_util.h"
  29
  30 namespace views {
  31 namespace {
  32
  33 class AccessibleWebViewRegistry {
  34  public:
  35   static AccessibleWebViewRegistry* GetInstance();
  36
  37   void RegisterWebView(View* web_view);
  38
  39   void UnregisterWebView(View* web_view);
  40
  41   // Given the view that received the request for the accessible
  42   // id in |top_view|, and the child id requested, return the native
  43   // accessible object with that child id from one of the WebViews in
  44   // |top_view|'s view hierarchy, if any.
  45   IAccessible* GetAccessibleFromWebView(View* top_view, long child_id);
  46
  47   // The system uses IAccessible APIs for many purposes, but only
  48   // assistive technology like screen readers uses IAccessible2.
  49   // Call this method to note that the IAccessible2 interface was queried and
  50   // that WebViews should be proactively notified that this interface will be
  51   // used. If this is enabled for the first time, this will explicitly call
  52   // QueryService with an argument of IAccessible2 on all WebViews, otherwise
  53   // it will just do it from now on.
  54   void EnableIAccessible2Support();
  55
  56  private:
  57   friend struct DefaultSingletonTraits<AccessibleWebViewRegistry>;
  58   AccessibleWebViewRegistry();
  59   ~AccessibleWebViewRegistry() {}
  60
  61   IAccessible* AccessibleObjectFromChildId(View* web_view, long child_id);
  62
  63   void QueryIAccessible2Interface(View* web_view);
  64
  65   // Set of all web views. We check whether each one is contained in a
  66   // top view dynamically rather than keeping track of a map.
  67   std::set<View*> web_views_;
  68
  69   // The most recent top view used in a call to GetAccessibleFromWebView.
  70   View* last_top_view_;
  71
  72   // The most recent web view where an accessible object was found,
  73   // corresponding to |last_top_view_|.
  74   View* last_web_view_;
  75
  76   // If IAccessible2 support is enabled, we query the IAccessible2 interface
  77   // of WebViews proactively when they're registered, so that they are
  78   // aware that they need to support this interface.
  79   bool iaccessible2_support_enabled_;
  80
  81   DISALLOW_COPY_AND_ASSIGN(AccessibleWebViewRegistry);
  82 };
  83
  84 AccessibleWebViewRegistry::AccessibleWebViewRegistry()
  85     : last_top_view_(NULL),
  86       last_web_view_(NULL),
  87       iaccessible2_support_enabled_(false) {
  88 }
  89
  90 AccessibleWebViewRegistry* AccessibleWebViewRegistry::GetInstance() {
  91   return Singleton<AccessibleWebViewRegistry>::get();
  92 }
  93
  94 void AccessibleWebViewRegistry::RegisterWebView(View* web_view) {
  95   DCHECK(web_views_.find(web_view) == web_views_.end());
  96   web_views_.insert(web_view);
  97
  98   if (iaccessible2_support_enabled_)
  99     QueryIAccessible2Interface(web_view);
 100 }
 101
 102 void AccessibleWebViewRegistry::UnregisterWebView(View* web_view) {
 103   DCHECK(web_views_.find(web_view) != web_views_.end());
 104   web_views_.erase(web_view);
 105   if (last_web_view_ == web_view) {
 106     last_top_view_ = NULL;
 107     last_web_view_ = NULL;
 108   }
 109 }
 110
 111 IAccessible* AccessibleWebViewRegistry::GetAccessibleFromWebView(
 112     View* top_view, long child_id) {
 113   // This function gets called frequently, so try to avoid searching all
 114   // of the web views if the notification is on the same web view that
 115   // sent the last one.
 116   if (last_top_view_ == top_view) {
 117     IAccessible* accessible =
 118         AccessibleObjectFromChildId(last_web_view_, child_id);
 119     if (accessible)
 120       return accessible;
 121   }
 122
 123   // Search all web views. For each one, first ensure it's a descendant
 124   // of this view where the event was posted - and if so, see if it owns
 125   // an accessible object with that child id. If so, save the view to speed
 126   // up the next notification.
 127   for (std::set<View*>::iterator iter = web_views_.begin();
 128        iter != web_views_.end(); ++iter) {
 129     View* web_view = *iter;
 130     if (top_view == web_view || !top_view->Contains(web_view))
 131       continue;
 132     IAccessible* accessible = AccessibleObjectFromChildId(web_view, child_id);
 133     if (accessible) {
 134       last_top_view_ = top_view;
 135       last_web_view_ = web_view;
 136       return accessible;
 137     }
 138   }
 139
 140   return NULL;
 141 }
 142
 143 void AccessibleWebViewRegistry::EnableIAccessible2Support() {
 144   if (iaccessible2_support_enabled_)
 145     return;
 146   iaccessible2_support_enabled_ = true;
 147   for (std::set<View*>::iterator iter = web_views_.begin();
 148        iter != web_views_.end(); ++iter) {
 149     QueryIAccessible2Interface(*iter);
 150   }
 151 }
 152
 153 IAccessible* AccessibleWebViewRegistry::AccessibleObjectFromChildId(
 154     View* web_view,
 155     long child_id) {
 156   IAccessible* web_view_accessible = web_view->GetNativeViewAccessible();
 157   if (web_view_accessible == NULL)
 158     return NULL;
 159
 160   VARIANT var_child;
 161   var_child.vt = VT_I4;
 162   var_child.lVal = child_id;
 163   IAccessible* result = NULL;
 164   if (S_OK == web_view_accessible->get_accChild(
 165       var_child, reinterpret_cast<IDispatch**>(&result))) {
 166     return result;
 167   }
 168
 169   return NULL;
 170 }
 171
 172 void AccessibleWebViewRegistry::QueryIAccessible2Interface(View* web_view) {
 173   IAccessible* web_view_accessible = web_view->GetNativeViewAccessible();
 174   if (!web_view_accessible)
 175     return;
 176
 177   base::win::ScopedComPtr<IServiceProvider> service_provider;
 178   if (S_OK != web_view_accessible->QueryInterface(service_provider.Receive()))
 179     return;
 180   base::win::ScopedComPtr<IAccessible2> iaccessible2;
 181   service_provider->QueryService(
 182       IID_IAccessible, IID_IAccessible2,
 183       reinterpret_cast<void**>(iaccessible2.Receive()));
 184 }
 185
 186 }  // anonymous namespace
 187
 188 // static
 189 long NativeViewAccessibilityWin::next_unique_id_ = 1;
 190 int NativeViewAccessibilityWin::view_storage_ids_[kMaxViewStorageIds] = {0};
 191 int NativeViewAccessibilityWin::next_view_storage_id_index_ = 0;
 192 std::vector<int> NativeViewAccessibilityWin::alert_target_view_storage_ids_;
 193
 194 // static
 195 NativeViewAccessibility* NativeViewAccessibility::Create(View* view) {
 196   // Make sure ATL is initialized in this module.
 197   ui::win::CreateATLModuleIfNeeded();
 198
 199   CComObject<NativeViewAccessibilityWin>* instance = NULL;
 200   HRESULT hr = CComObject<NativeViewAccessibilityWin>::CreateInstance(
 201       &instance);
 202   DCHECK(SUCCEEDED(hr));
 203   instance->set_view(view);
 204   instance->AddRef();
 205   return instance;
 206 }
 207
 208 NativeViewAccessibilityWin::NativeViewAccessibilityWin()
 209     : view_(NULL),
 210       unique_id_(next_unique_id_++) {
 211 }
 212
 213 NativeViewAccessibilityWin::~NativeViewAccessibilityWin() {
 214   RemoveAlertTarget();
 215 }
 216
 217 void NativeViewAccessibilityWin::NotifyAccessibilityEvent(
 218     ui::AXEvent event_type) {
 219   if (!view_)
 220     return;
 221
 222   ViewStorage* view_storage = ViewStorage::GetInstance();
 223   HWND hwnd = HWNDForView(view_);
 224   int view_storage_id = view_storage_ids_[next_view_storage_id_index_];
 225   if (view_storage_id == 0) {
 226     view_storage_id = view_storage->CreateStorageID();
 227     view_storage_ids_[next_view_storage_id_index_] = view_storage_id;
 228   } else {
 229     view_storage->RemoveView(view_storage_id);
 230   }
 231   view_storage->StoreView(view_storage_id, view_);
 232
 233   // Positive child ids are used for enumerating direct children,
 234   // negative child ids can be used as unique ids to refer to a specific
 235   // descendants.  Make index into view_storage_ids_ into a negative child id.
 236   int child_id =
 237       base::win::kFirstViewsAccessibilityId - next_view_storage_id_index_;
 238   ::NotifyWinEvent(MSAAEvent(event_type), hwnd, OBJID_CLIENT, child_id);
 239   next_view_storage_id_index_ =
 240       (next_view_storage_id_index_ + 1) % kMaxViewStorageIds;
 241
 242   // Keep track of views that are a target of an alert event.
 243   if (event_type == ui::AX_EVENT_ALERT)
 244     AddAlertTarget();
 245 }
 246
 247 gfx::NativeViewAccessible NativeViewAccessibilityWin::GetNativeObject() {
 248   return this;
 249 }
 250
 251 void NativeViewAccessibilityWin::Destroy() {
 252   view_ = NULL;
 253   Release();
 254 }
 255
 256 STDMETHODIMP NativeViewAccessibilityWin::accHitTest(
 257     LONG x_left, LONG y_top, VARIANT* child) {
 258   if (!child)
 259     return E_INVALIDARG;
 260
 261   if (!view_ || !view_->GetWidget())
 262     return E_FAIL;
 263
 264   // If this is a root view, our widget might have child widgets.
 265   // Search child widgets first, since they're on top in the z-order.
 266   if (view_->GetWidget()->GetRootView() == view_) {
 267     std::vector<Widget*> child_widgets;
 268     PopulateChildWidgetVector(&child_widgets);
 269     for (size_t i = 0; i < child_widgets.size(); ++i) {
 270       Widget* child_widget = child_widgets[i];
 271       IAccessible* child_accessible =
 272           child_widget->GetRootView()->GetNativeViewAccessible();
 273       HRESULT result = child_accessible->accHitTest(x_left, y_top, child);
 274       if (result == S_OK)
 275         return result;
 276     }
 277   }
 278
 279   gfx::Point point(x_left, y_top);
 280   View::ConvertPointFromScreen(view_, &point);
 281
 282   // If the point is not inside this view, return false.
 283   if (!view_->HitTestPoint(point)) {
 284     child->vt = VT_EMPTY;
 285     return S_FALSE;
 286   }
 287
 288   // Check if the point is within any of the immediate children of this
 289   // view.
 290   View* hit_child_view = NULL;
 291   for (int i = view_->child_count() - 1; i >= 0; --i) {
 292     View* child_view = view_->child_at(i);
 293     if (!child_view->visible())
 294       continue;
 295
 296     gfx::Point point_in_child_coords(point);
 297     view_->ConvertPointToTarget(view_, child_view, &point_in_child_coords);
 298     if (child_view->HitTestPoint(point_in_child_coords)) {
 299       hit_child_view = child_view;
 300       break;
 301     }
 302   }
 303
 304   // If the point was within one of this view's immediate children,
 305   // call accHitTest recursively on that child's native view accessible -
 306   // which may be a recursive call to this function or it may be overridden,
 307   // for example in the case of a WebView.
 308   if (hit_child_view) {
 309     HRESULT result = hit_child_view->GetNativeViewAccessible()->accHitTest(
 310         x_left, y_top, child);
 311
 312     // If the recursive call returned CHILDID_SELF, we have to convert that
 313     // into a VT_DISPATCH for the return value to this call.
 314     if (S_OK == result && child->vt == VT_I4 && child->lVal == CHILDID_SELF) {
 315       child->vt = VT_DISPATCH;
 316       child->pdispVal = hit_child_view->GetNativeViewAccessible();
 317       // Always increment ref when returning a reference to a COM object.
 318       child->pdispVal->AddRef();
 319     }
 320     return result;
 321   }
 322
 323   // This object is the best match, so return CHILDID_SELF. It's tempting to
 324   // simplify the logic and use VT_DISPATCH everywhere, but the Windows
 325   // call AccessibleObjectFromPoint will keep calling accHitTest until some
 326   // object returns CHILDID_SELF.
 327   child->vt = VT_I4;
 328   child->lVal = CHILDID_SELF;
 329   return S_OK;
 330 }
 331
 332 HRESULT NativeViewAccessibilityWin::accDoDefaultAction(VARIANT var_id) {
 333   if (!IsValidId(var_id))
 334     return E_INVALIDARG;
 335
 336   // The object does not support the method. This value is returned for
 337   // controls that do not perform actions, such as edit fields.
 338   return DISP_E_MEMBERNOTFOUND;
 339 }
 340
 341 STDMETHODIMP NativeViewAccessibilityWin::accLocation(
 342     LONG* x_left, LONG* y_top, LONG* width, LONG* height, VARIANT var_id) {
 343   if (!IsValidId(var_id) || !x_left || !y_top || !width || !height)
 344     return E_INVALIDARG;
 345
 346   if (!view_)
 347     return E_FAIL;
 348
 349   if (!view_->bounds().IsEmpty()) {
 350     *width  = view_->width();
 351     *height = view_->height();
 352     gfx::Point topleft(view_->bounds().origin());
 353     View::ConvertPointToScreen(
 354         view_->parent() ? view_->parent() : view_, &topleft);
 355     *x_left = topleft.x();
 356     *y_top  = topleft.y();
 357   } else {
 358     return E_FAIL;
 359   }
 360   return S_OK;
 361 }
 362
 363 STDMETHODIMP NativeViewAccessibilityWin::accNavigate(
 364     LONG nav_dir, VARIANT start, VARIANT* end) {
 365   if (start.vt != VT_I4 || !end)
 366     return E_INVALIDARG;
 367
 368   if (!view_)
 369     return E_FAIL;
 370
 371   switch (nav_dir) {
 372     case NAVDIR_FIRSTCHILD:
 373     case NAVDIR_LASTCHILD: {
 374       if (start.lVal != CHILDID_SELF) {
 375         // Start of navigation must be on the View itself.
 376         return E_INVALIDARG;
 377       } else if (!view_->has_children()) {
 378         // No children found.
 379         return S_FALSE;
 380       }
 381
 382       // Set child_id based on first or last child.
 383       int child_id = 0;
 384       if (nav_dir == NAVDIR_LASTCHILD)
 385         child_id = view_->child_count() - 1;
 386
 387       View* child = view_->child_at(child_id);
 388       end->vt = VT_DISPATCH;
 389       end->pdispVal = child->GetNativeViewAccessible();
 390       end->pdispVal->AddRef();
 391       return S_OK;
 392     }
 393     case NAVDIR_LEFT:
 394     case NAVDIR_UP:
 395     case NAVDIR_PREVIOUS:
 396     case NAVDIR_RIGHT:
 397     case NAVDIR_DOWN:
 398     case NAVDIR_NEXT: {
 399       // Retrieve parent to access view index and perform bounds checking.
 400       View* parent = view_->parent();
 401       if (!parent) {
 402         return E_FAIL;
 403       }
 404
 405       if (start.lVal == CHILDID_SELF) {
 406         int view_index = parent->GetIndexOf(view_);
 407         // Check navigation bounds, adjusting for View child indexing (MSAA
 408         // child indexing starts with 1, whereas View indexing starts with 0).
 409         if (!IsValidNav(nav_dir, view_index, -1,
 410                         parent->child_count() - 1)) {
 411           // Navigation attempted to go out-of-bounds.
 412           end->vt = VT_EMPTY;
 413           return S_FALSE;
 414         } else {
 415           if (IsNavDirNext(nav_dir)) {
 416             view_index += 1;
 417           } else {
 418             view_index -=1;
 419           }
 420         }
 421
 422         View* child = parent->child_at(view_index);
 423         end->pdispVal = child->GetNativeViewAccessible();
 424         end->vt = VT_DISPATCH;
 425         end->pdispVal->AddRef();
 426         return S_OK;
 427       } else {
 428         // Check navigation bounds, adjusting for MSAA child indexing (MSAA
 429         // child indexing starts with 1, whereas View indexing starts with 0).
 430         if (!IsValidNav(nav_dir, start.lVal, 0, parent->child_count() + 1)) {
 431             // Navigation attempted to go out-of-bounds.
 432             end->vt = VT_EMPTY;
 433             return S_FALSE;
 434           } else {
 435             if (IsNavDirNext(nav_dir)) {
 436               start.lVal += 1;
 437             } else {
 438               start.lVal -= 1;
 439             }
 440         }
 441
 442         HRESULT result = this->get_accChild(start, &end->pdispVal);
 443         if (result == S_FALSE) {
 444           // Child is a leaf.
 445           end->vt = VT_I4;
 446           end->lVal = start.lVal;
 447         } else if (result == E_INVALIDARG) {
 448           return E_INVALIDARG;
 449         } else {
 450           // Child is not a leaf.
 451           end->vt = VT_DISPATCH;
 452         }
 453       }
 454       break;
 455     }
 456     default:
 457       return E_INVALIDARG;
 458   }
 459   // Navigation performed correctly. Global return for this function, if no
 460   // error triggered an escape earlier.
 461   return S_OK;
 462 }
 463
 464 STDMETHODIMP NativeViewAccessibilityWin::get_accChild(VARIANT var_child,
 465                                                       IDispatch** disp_child) {
 466   if (var_child.vt != VT_I4 || !disp_child)
 467     return E_INVALIDARG;
 468
 469   if (!view_ || !view_->GetWidget())
 470     return E_FAIL;
 471
 472   LONG child_id = V_I4(&var_child);
 473
 474   if (child_id == CHILDID_SELF) {
 475     // Remain with the same dispatch.
 476     return S_OK;
 477   }
 478
 479   // If this is a root view, our widget might have child widgets. Include
 480   std::vector<Widget*> child_widgets;
 481   if (view_->GetWidget()->GetRootView() == view_)
 482     PopulateChildWidgetVector(&child_widgets);
 483   int child_widget_count = static_cast<int>(child_widgets.size());
 484
 485   View* child_view = NULL;
 486   if (child_id > 0) {
 487     // Positive child ids are a 1-based child index, used by clients
 488     // that want to enumerate all immediate children.
 489     int child_id_as_index = child_id - 1;
 490     if (child_id_as_index < view_->child_count()) {
 491       child_view = view_->child_at(child_id_as_index);
 492     } else if (child_id_as_index < view_->child_count() + child_widget_count) {
 493       Widget* child_widget =
 494           child_widgets[child_id_as_index - view_->child_count()];
 495       child_view = child_widget->GetRootView();
 496     }
 497   } else {
 498     // Negative child ids can be used to map to any descendant.
 499     // Check child widget first.
 500     for (int i = 0; i < child_widget_count; i++) {
 501       Widget* child_widget = child_widgets[i];
 502       IAccessible* child_accessible =
 503           child_widget->GetRootView()->GetNativeViewAccessible();
 504       HRESULT result = child_accessible->get_accChild(var_child, disp_child);
 505       if (result == S_OK)
 506         return result;
 507     }
 508
 509     // We map child ids to a view storage id that can refer to a
 510     // specific view (if that view still exists).
 511     int view_storage_id_index =
 512         base::win::kFirstViewsAccessibilityId - child_id;
 513     if (view_storage_id_index >= 0 &&
 514         view_storage_id_index < kMaxViewStorageIds) {
 515       int view_storage_id = view_storage_ids_[view_storage_id_index];
 516       ViewStorage* view_storage = ViewStorage::GetInstance();
 517       child_view = view_storage->RetrieveView(view_storage_id);
 518     } else {
 519       *disp_child = AccessibleWebViewRegistry::GetInstance()->
 520           GetAccessibleFromWebView(view_, child_id);
 521       if (*disp_child)
 522         return S_OK;
 523     }
 524   }
 525
 526   if (!child_view) {
 527     // No child found.
 528     *disp_child = NULL;
 529     return E_FAIL;
 530   }
 531
 532   *disp_child = child_view->GetNativeViewAccessible();
 533   (*disp_child)->AddRef();
 534   return S_OK;
 535 }
 536
 537 STDMETHODIMP NativeViewAccessibilityWin::get_accChildCount(LONG* child_count) {
 538   if (!child_count)
 539     return E_INVALIDARG;
 540
 541   if (!view_ || !view_->GetWidget())
 542     return E_FAIL;
 543
 544   *child_count = view_->child_count();
 545
 546   // If this is a root view, our widget might have child widgets. Include
 547   // them, too.
 548   if (view_->GetWidget()->GetRootView() == view_) {
 549     std::vector<Widget*> child_widgets;
 550     PopulateChildWidgetVector(&child_widgets);
 551     *child_count += child_widgets.size();
 552   }
 553
 554   return S_OK;
 555 }
 556
 557 STDMETHODIMP NativeViewAccessibilityWin::get_accDefaultAction(
 558     VARIANT var_id, BSTR* def_action) {
 559   if (!IsValidId(var_id) || !def_action)
 560     return E_INVALIDARG;
 561
 562   if (!view_)
 563     return E_FAIL;
 564
 565   ui::AXViewState state;
 566   view_->GetAccessibleState(&state);
 567   base::string16 temp_action = state.default_action;
 568
 569   if (!temp_action.empty()) {
 570     *def_action = SysAllocString(temp_action.c_str());
 571   } else {
 572     return S_FALSE;
 573   }
 574
 575   return S_OK;
 576 }
 577
 578 STDMETHODIMP NativeViewAccessibilityWin::get_accDescription(
 579     VARIANT var_id, BSTR* desc) {
 580   if (!IsValidId(var_id) || !desc)
 581     return E_INVALIDARG;
 582
 583   if (!view_)
 584     return E_FAIL;
 585
 586   base::string16 temp_desc;
 587
 588   view_->GetTooltipText(gfx::Point(), &temp_desc);
 589   if (!temp_desc.empty()) {
 590     *desc = SysAllocString(temp_desc.c_str());
 591   } else {
 592     return S_FALSE;
 593   }
 594
 595   return S_OK;
 596 }
 597
 598 STDMETHODIMP NativeViewAccessibilityWin::get_accFocus(VARIANT* focus_child) {
 599   if (!focus_child)
 600     return E_INVALIDARG;
 601
 602   if (!view_)
 603     return E_FAIL;
 604
 605   FocusManager* focus_manager = view_->GetFocusManager();
 606   View* focus = focus_manager ? focus_manager->GetFocusedView() : NULL;
 607   if (focus == view_) {
 608     // This view has focus.
 609     focus_child->vt = VT_I4;
 610     focus_child->lVal = CHILDID_SELF;
 611   } else if (focus && view_->Contains(focus)) {
 612     // Return the child object that has the keyboard focus.
 613     focus_child->vt = VT_DISPATCH;
 614     focus_child->pdispVal = focus->GetNativeViewAccessible();
 615     focus_child->pdispVal->AddRef();
 616     return S_OK;
 617   } else {
 618     // Neither this object nor any of its children has the keyboard focus.
 619     focus_child->vt = VT_EMPTY;
 620   }
 621   return S_OK;
 622 }
 623
 624 STDMETHODIMP NativeViewAccessibilityWin::get_accKeyboardShortcut(
 625     VARIANT var_id, BSTR* acc_key) {
 626   if (!IsValidId(var_id) || !acc_key)
 627     return E_INVALIDARG;
 628
 629   if (!view_)
 630     return E_FAIL;
 631
 632   ui::AXViewState state;
 633   view_->GetAccessibleState(&state);
 634   base::string16 temp_key = state.keyboard_shortcut;
 635
 636   if (!temp_key.empty()) {
 637     *acc_key = SysAllocString(temp_key.c_str());
 638   } else {
 639     return S_FALSE;
 640   }
 641
 642   return S_OK;
 643 }
 644
 645 STDMETHODIMP NativeViewAccessibilityWin::get_accName(
 646     VARIANT var_id, BSTR* name) {
 647   if (!IsValidId(var_id) || !name)
 648     return E_INVALIDARG;
 649
 650   if (!view_)
 651     return E_FAIL;
 652
 653   // Retrieve the current view's name.
 654   ui::AXViewState state;
 655   view_->GetAccessibleState(&state);
 656   base::string16 temp_name = state.name;
 657   if (!temp_name.empty()) {
 658     // Return name retrieved.
 659     *name = SysAllocString(temp_name.c_str());
 660   } else {
 661     // If view has no name, return S_FALSE.
 662     return S_FALSE;
 663   }
 664
 665   return S_OK;
 666 }
 667
 668 STDMETHODIMP NativeViewAccessibilityWin::get_accParent(
 669     IDispatch** disp_parent) {
 670   if (!disp_parent)
 671     return E_INVALIDARG;
 672
 673   if (!view_)
 674     return E_FAIL;
 675
 676   *disp_parent = NULL;
 677   View* parent_view = view_->parent();
 678
 679   if (!parent_view) {
 680     HWND hwnd = HWNDForView(view_);
 681     if (!hwnd)
 682       return S_FALSE;
 683
 684     return ::AccessibleObjectFromWindow(
 685         hwnd, OBJID_WINDOW, IID_IAccessible,
 686         reinterpret_cast<void**>(disp_parent));
 687   }
 688
 689   *disp_parent = parent_view->GetNativeViewAccessible();
 690   (*disp_parent)->AddRef();
 691   return S_OK;
 692 }
 693
 694 STDMETHODIMP NativeViewAccessibilityWin::get_accRole(
 695     VARIANT var_id, VARIANT* role) {
 696   if (!IsValidId(var_id) || !role)
 697     return E_INVALIDARG;
 698
 699   if (!view_)
 700     return E_FAIL;
 701
 702   ui::AXViewState state;
 703   view_->GetAccessibleState(&state);
 704   role->vt = VT_I4;
 705   role->lVal = MSAARole(state.role);
 706   return S_OK;
 707 }
 708
 709 STDMETHODIMP NativeViewAccessibilityWin::get_accState(
 710     VARIANT var_id, VARIANT* state) {
 711   // This returns MSAA states. See also the IAccessible2 interface
 712   // get_states().
 713
 714   if (!IsValidId(var_id) || !state)
 715     return E_INVALIDARG;
 716
 717   if (!view_)
 718     return E_FAIL;
 719
 720   state->vt = VT_I4;
 721
 722   // Retrieve all currently applicable states of the parent.
 723   SetState(state, view_);
 724
 725   // Make sure that state is not empty, and has the proper type.
 726   if (state->vt == VT_EMPTY)
 727     return E_FAIL;
 728
 729   return S_OK;
 730 }
 731
 732 STDMETHODIMP NativeViewAccessibilityWin::get_accValue(VARIANT var_id,
 733                                                       BSTR* value) {
 734   if (!IsValidId(var_id) || !value)
 735     return E_INVALIDARG;
 736
 737   if (!view_)
 738     return E_FAIL;
 739
 740   // Retrieve the current view's value.
 741   ui::AXViewState state;
 742   view_->GetAccessibleState(&state);
 743   base::string16 temp_value = state.value;
 744
 745   if (!temp_value.empty()) {
 746     // Return value retrieved.
 747     *value = SysAllocString(temp_value.c_str());
 748   } else {
 749     // If view has no value, fall back into the default implementation.
 750     *value = NULL;
 751     return E_NOTIMPL;
 752   }
 753
 754   return S_OK;
 755 }
 756
 757 STDMETHODIMP NativeViewAccessibilityWin::put_accValue(VARIANT var_id,
 758                                                       BSTR new_value) {
 759   if (!IsValidId(var_id) || !new_value)
 760     return E_INVALIDARG;
 761
 762   if (!view_)
 763     return E_FAIL;
 764
 765   // Return an error if the view can't set the value.
 766   ui::AXViewState state;
 767   view_->GetAccessibleState(&state);
 768   if (state.set_value_callback.is_null())
 769     return E_FAIL;
 770
 771   state.set_value_callback.Run(new_value);
 772   return S_OK;
 773 }
 774
 775 // IAccessible functions not supported.
 776
 777 STDMETHODIMP NativeViewAccessibilityWin::get_accSelection(VARIANT* selected) {
 778   if (selected)
 779     selected->vt = VT_EMPTY;
 780   return E_NOTIMPL;
 781 }
 782
 783 STDMETHODIMP NativeViewAccessibilityWin::accSelect(
 784     LONG flagsSelect, VARIANT var_id) {
 785   return E_NOTIMPL;
 786 }
 787
 788 STDMETHODIMP NativeViewAccessibilityWin::get_accHelp(
 789     VARIANT var_id, BSTR* help) {
 790   base::string16 temp = base::UTF8ToUTF16(view_->GetClassName());
 791   *help = SysAllocString(temp.c_str());
 792   return S_OK;
 793 }
 794
 795 STDMETHODIMP NativeViewAccessibilityWin::get_accHelpTopic(
 796     BSTR* help_file, VARIANT var_id, LONG* topic_id) {
 797   if (help_file) {
 798     *help_file = NULL;
 799   }
 800   if (topic_id) {
 801     *topic_id = static_cast<LONG>(-1);
 802   }
 803   return E_NOTIMPL;
 804 }
 805
 806 STDMETHODIMP NativeViewAccessibilityWin::put_accName(
 807     VARIANT var_id, BSTR put_name) {
 808   // Deprecated.
 809   return E_NOTIMPL;
 810 }
 811
 812 //
 813 // IAccessible2
 814 //
 815
 816 STDMETHODIMP NativeViewAccessibilityWin::role(LONG* role) {
 817   if (!view_)
 818     return E_FAIL;
 819
 820   if (!role)
 821     return E_INVALIDARG;
 822
 823   ui::AXViewState state;
 824   view_->GetAccessibleState(&state);
 825   *role = MSAARole(state.role);
 826   return S_OK;
 827 }
 828
 829 STDMETHODIMP NativeViewAccessibilityWin::get_states(AccessibleStates* states) {
 830   // This returns IAccessible2 states, which supplement MSAA states.
 831   // See also the MSAA interface get_accState.
 832
 833   if (!view_)
 834     return E_FAIL;
 835
 836   if (!states)
 837     return E_INVALIDARG;
 838
 839   ui::AXViewState state;
 840   view_->GetAccessibleState(&state);
 841
 842   // There are only a couple of states we need to support
 843   // in IAccessible2. If any more are added, we may want to
 844   // add a helper function like MSAAState.
 845   *states = IA2_STATE_OPAQUE;
 846   if (state.HasStateFlag(ui::AX_STATE_EDITABLE))
 847     *states |= IA2_STATE_EDITABLE;
 848
 849   return S_OK;
 850 }
 851
 852 STDMETHODIMP NativeViewAccessibilityWin::get_uniqueID(LONG* unique_id) {
 853   if (!view_)
 854     return E_FAIL;
 855
 856   if (!unique_id)
 857     return E_INVALIDARG;
 858
 859   *unique_id = unique_id_;
 860   return S_OK;
 861 }
 862
 863 STDMETHODIMP NativeViewAccessibilityWin::get_windowHandle(HWND* window_handle) {
 864   if (!view_)
 865     return E_FAIL;
 866
 867   if (!window_handle)
 868     return E_INVALIDARG;
 869
 870   *window_handle = HWNDForView(view_);
 871   return *window_handle ? S_OK : S_FALSE;
 872 }
 873
 874 STDMETHODIMP NativeViewAccessibilityWin::get_relationTargetsOfType(
 875     BSTR type_bstr,
 876     long max_targets,
 877     IUnknown ***targets,
 878     long *n_targets) {
 879   if (!view_)
 880     return E_FAIL;
 881
 882   if (!targets || !n_targets)
 883     return E_INVALIDARG;
 884
 885   *n_targets = 0;
 886   *targets = NULL;
 887
 888   // Only respond to requests for relations of type "alerts" on the
 889   // root view.
 890   base::string16 type(type_bstr);
 891   if (type != L"alerts" || view_->parent())
 892     return S_FALSE;
 893
 894   // Collect all of the alert views that are still valid.
 895   std::vector<View*> alert_views;
 896   ViewStorage* view_storage = ViewStorage::GetInstance();
 897   for (size_t i = 0; i < alert_target_view_storage_ids_.size(); ++i) {
 898     int view_storage_id = alert_target_view_storage_ids_[i];
 899     View* view = view_storage->RetrieveView(view_storage_id);
 900     if (!view || !view_->Contains(view))
 901       continue;
 902     alert_views.push_back(view);
 903   }
 904
 905   long count = alert_views.size();
 906   if (count == 0)
 907     return S_FALSE;
 908
 909   // Don't return more targets than max_targets - but note that the caller
 910   // is allowed to specify max_targets=0 to mean no limit.
 911   if (max_targets > 0 && count > max_targets)
 912     count = max_targets;
 913
 914   // Return the number of targets.
 915   *n_targets = count;
 916
 917   // Allocate COM memory for the result array and populate it.
 918   *targets = static_cast<IUnknown**>(
 919       CoTaskMemAlloc(count * sizeof(IUnknown*)));
 920   for (long i = 0; i < count; ++i) {
 921     (*targets)[i] = alert_views[i]->GetNativeViewAccessible();
 922     (*targets)[i]->AddRef();
 923   }
 924   return S_OK;
 925 }
 926
 927 //
 928 // IAccessibleText
 929 //
 930
 931 STDMETHODIMP NativeViewAccessibilityWin::get_nCharacters(LONG* n_characters) {
 932   if (!view_)
 933     return E_FAIL;
 934
 935   if (!n_characters)
 936     return E_INVALIDARG;
 937
 938   base::string16 text = TextForIAccessibleText();
 939   *n_characters = static_cast<LONG>(text.size());
 940   return S_OK;
 941 }
 942
 943 STDMETHODIMP NativeViewAccessibilityWin::get_caretOffset(LONG* offset) {
 944   if (!view_)
 945     return E_FAIL;
 946
 947   if (!offset)
 948     return E_INVALIDARG;
 949
 950   ui::AXViewState state;
 951   view_->GetAccessibleState(&state);
 952   *offset = static_cast<LONG>(state.selection_end);
 953   return S_OK;
 954 }
 955
 956 STDMETHODIMP NativeViewAccessibilityWin::get_nSelections(LONG* n_selections) {
 957   if (!view_)
 958     return E_FAIL;
 959
 960   if (!n_selections)
 961     return E_INVALIDARG;
 962
 963   ui::AXViewState state;
 964   view_->GetAccessibleState(&state);
 965   if (state.selection_start != state.selection_end)
 966     *n_selections = 1;
 967   else
 968     *n_selections = 0;
 969   return S_OK;
 970 }
 971
 972 STDMETHODIMP NativeViewAccessibilityWin::get_selection(LONG selection_index,
 973                                                       LONG* start_offset,
 974                                                       LONG* end_offset) {
 975   if (!view_)
 976     return E_FAIL;
 977
 978   if (!start_offset || !end_offset || selection_index != 0)
 979     return E_INVALIDARG;
 980
 981   ui::AXViewState state;
 982   view_->GetAccessibleState(&state);
 983   *start_offset = static_cast<LONG>(state.selection_start);
 984   *end_offset = static_cast<LONG>(state.selection_end);
 985   return S_OK;
 986 }
 987
 988 STDMETHODIMP NativeViewAccessibilityWin::get_text(LONG start_offset,
 989                                                   LONG end_offset,
 990                                                   BSTR* text) {
 991   if (!view_)
 992     return E_FAIL;
 993
 994   ui::AXViewState state;
 995   view_->GetAccessibleState(&state);
 996   base::string16 text_str = TextForIAccessibleText();
 997   LONG len = static_cast<LONG>(text_str.size());
 998
 999   if (start_offset == IA2_TEXT_OFFSET_LENGTH) {
1000     start_offset = len;
1001   } else if (start_offset == IA2_TEXT_OFFSET_CARET) {
1002     start_offset = static_cast<LONG>(state.selection_end);
1003   }
1004   if (end_offset == IA2_TEXT_OFFSET_LENGTH) {
1005     end_offset = static_cast<LONG>(text_str.size());
1006   } else if (end_offset == IA2_TEXT_OFFSET_CARET) {
1007     end_offset = static_cast<LONG>(state.selection_end);
1008   }
1009
1010   // The spec allows the arguments to be reversed.
1011   if (start_offset > end_offset) {
1012     LONG tmp = start_offset;
1013     start_offset = end_offset;
1014     end_offset = tmp;
1015   }
1016
1017   // The spec does not allow the start or end offsets to be out or range;
1018   // we must return an error if so.
1019   if (start_offset < 0)
1020     return E_INVALIDARG;
1021   if (end_offset > len)
1022     return E_INVALIDARG;
1023
1024   base::string16 substr =
1025       text_str.substr(start_offset, end_offset - start_offset);
1026   if (substr.empty())
1027     return S_FALSE;
1028
1029   *text = SysAllocString(substr.c_str());
1030   DCHECK(*text);
1031   return S_OK;
1032 }
1033
1034 STDMETHODIMP NativeViewAccessibilityWin::get_textAtOffset(
1035     LONG offset,
1036     enum IA2TextBoundaryType boundary_type,
1037     LONG* start_offset, LONG* end_offset,
1038     BSTR* text) {
1039   if (!start_offset || !end_offset || !text)
1040     return E_INVALIDARG;
1041
1042   // The IAccessible2 spec says we don't have to implement the "sentence"
1043   // boundary type, we can just let the screenreader handle it.
1044   if (boundary_type == IA2_TEXT_BOUNDARY_SENTENCE) {
1045     *start_offset = 0;
1046     *end_offset = 0;
1047     *text = NULL;
1048     return S_FALSE;
1049   }
1050
1051   const base::string16& text_str = TextForIAccessibleText();
1052
1053   *start_offset = FindBoundary(
1054       text_str, boundary_type, offset, ui::BACKWARDS_DIRECTION);
1055   *end_offset = FindBoundary(
1056       text_str, boundary_type, offset, ui::FORWARDS_DIRECTION);
1057   return get_text(*start_offset, *end_offset, text);
1058 }
1059
1060 STDMETHODIMP NativeViewAccessibilityWin::get_textBeforeOffset(
1061     LONG offset,
1062     enum IA2TextBoundaryType boundary_type,
1063     LONG* start_offset, LONG* end_offset,
1064     BSTR* text) {
1065   if (!start_offset || !end_offset || !text)
1066     return E_INVALIDARG;
1067
1068   // The IAccessible2 spec says we don't have to implement the "sentence"
1069   // boundary type, we can just let the screenreader handle it.
1070   if (boundary_type == IA2_TEXT_BOUNDARY_SENTENCE) {
1071     *start_offset = 0;
1072     *end_offset = 0;
1073     *text = NULL;
1074     return S_FALSE;
1075   }
1076
1077   const base::string16& text_str = TextForIAccessibleText();
1078
1079   *start_offset = FindBoundary(
1080       text_str, boundary_type, offset, ui::BACKWARDS_DIRECTION);
1081   *end_offset = offset;
1082   return get_text(*start_offset, *end_offset, text);
1083 }
1084
1085 STDMETHODIMP NativeViewAccessibilityWin::get_textAfterOffset(
1086     LONG offset,
1087     enum IA2TextBoundaryType boundary_type,
1088     LONG* start_offset, LONG* end_offset,
1089     BSTR* text) {
1090   if (!start_offset || !end_offset || !text)
1091     return E_INVALIDARG;
1092
1093   // The IAccessible2 spec says we don't have to implement the "sentence"
1094   // boundary type, we can just let the screenreader handle it.
1095   if (boundary_type == IA2_TEXT_BOUNDARY_SENTENCE) {
1096     *start_offset = 0;
1097     *end_offset = 0;
1098     *text = NULL;
1099     return S_FALSE;
1100   }
1101
1102   const base::string16& text_str = TextForIAccessibleText();
1103
1104   *start_offset = offset;
1105   *end_offset = FindBoundary(
1106       text_str, boundary_type, offset, ui::FORWARDS_DIRECTION);
1107   return get_text(*start_offset, *end_offset, text);
1108 }
1109
1110 STDMETHODIMP NativeViewAccessibilityWin::get_offsetAtPoint(
1111     LONG x, LONG y, enum IA2CoordinateType coord_type, LONG* offset) {
1112   if (!view_)
1113     return E_FAIL;
1114
1115   if (!offset)
1116     return E_INVALIDARG;
1117
1118   // We don't support this method, but we have to return something
1119   // rather than E_NOTIMPL or screen readers will complain.
1120   *offset = 0;
1121   return S_OK;
1122 }
1123
1124 //
1125 // IServiceProvider methods.
1126 //
1127
1128 STDMETHODIMP NativeViewAccessibilityWin::QueryService(
1129     REFGUID guidService, REFIID riid, void** object) {
1130   if (!view_)
1131     return E_FAIL;
1132
1133   if (riid == IID_IAccessible2 || riid == IID_IAccessible2_2)
1134     AccessibleWebViewRegistry::GetInstance()->EnableIAccessible2Support();
1135
1136   if (guidService == IID_IAccessible ||
1137       guidService == IID_IAccessible2 ||
1138       guidService == IID_IAccessible2_2 ||
1139       guidService == IID_IAccessibleText)  {
1140     return QueryInterface(riid, object);
1141   }
1142
1143   // We only support the IAccessibleEx interface on Windows 8 and above. This
1144   // is needed for the On screen Keyboard to show up in metro mode, when the
1145   // user taps an editable region in the window.
1146   // All methods in the IAccessibleEx interface are unimplemented.
1147   if (riid == IID_IAccessibleEx &&
1148       base::win::GetVersion() >= base::win::VERSION_WIN8) {
1149     return QueryInterface(riid, object);
1150   }
1151
1152   *object = NULL;
1153   return E_FAIL;
1154 }
1155
1156 STDMETHODIMP NativeViewAccessibilityWin::GetPatternProvider(
1157     PATTERNID id, IUnknown** provider) {
1158   DVLOG(1) << "In Function: "
1159            << __FUNCTION__
1160            << " for pattern id: "
1161            << id;
1162   if (id == UIA_ValuePatternId || id == UIA_TextPatternId) {
1163     ui::AXViewState state;
1164     view_->GetAccessibleState(&state);
1165     long role = MSAARole(state.role);
1166
1167     if (role == ROLE_SYSTEM_TEXT) {
1168       DVLOG(1) << "Returning UIA text provider";
1169       base::win::UIATextProvider::CreateTextProvider(
1170           state.value, true, provider);
1171       return S_OK;
1172     }
1173   }
1174   return E_NOTIMPL;
1175 }
1176
1177 STDMETHODIMP NativeViewAccessibilityWin::GetPropertyValue(PROPERTYID id,
1178                                                           VARIANT* ret) {
1179   DVLOG(1) << "In Function: "
1180            << __FUNCTION__
1181            << " for property id: "
1182            << id;
1183   if (id == UIA_ControlTypePropertyId) {
1184     ui::AXViewState state;
1185     view_->GetAccessibleState(&state);
1186     long role = MSAARole(state.role);
1187     if (role == ROLE_SYSTEM_TEXT) {
1188       V_VT(ret) = VT_I4;
1189       ret->lVal = UIA_EditControlTypeId;
1190       DVLOG(1) << "Returning Edit control type";
1191     } else {
1192       DVLOG(1) << "Returning empty control type";
1193       V_VT(ret) = VT_EMPTY;
1194     }
1195   } else {
1196     V_VT(ret) = VT_EMPTY;
1197   }
1198   return S_OK;
1199 }
1200
1201 //
1202 // Static methods.
1203 //
1204
1205 void NativeViewAccessibility::RegisterWebView(View* web_view) {
1206   AccessibleWebViewRegistry::GetInstance()->RegisterWebView(web_view);
1207 }
1208
1209 void NativeViewAccessibility::UnregisterWebView(View* web_view) {
1210   AccessibleWebViewRegistry::GetInstance()->UnregisterWebView(web_view);
1211 }
1212
1213 int32 NativeViewAccessibilityWin::MSAAEvent(ui::AXEvent event) {
1214   switch (event) {
1215     case ui::AX_EVENT_ALERT:
1216       return EVENT_SYSTEM_ALERT;
1217     case ui::AX_EVENT_FOCUS:
1218       return EVENT_OBJECT_FOCUS;
1219     case ui::AX_EVENT_MENU_START:
1220       return EVENT_SYSTEM_MENUSTART;
1221     case ui::AX_EVENT_MENU_END:
1222       return EVENT_SYSTEM_MENUEND;
1223     case ui::AX_EVENT_MENU_POPUP_START:
1224       return EVENT_SYSTEM_MENUPOPUPSTART;
1225     case ui::AX_EVENT_MENU_POPUP_END:
1226       return EVENT_SYSTEM_MENUPOPUPEND;
1227     case ui::AX_EVENT_TEXT_CHANGED:
1228       return EVENT_OBJECT_NAMECHANGE;
1229     case ui::AX_EVENT_SELECTION_CHANGED:
1230       return IA2_EVENT_TEXT_CARET_MOVED;
1231     case ui::AX_EVENT_VALUE_CHANGED:
1232       return EVENT_OBJECT_VALUECHANGE;
1233     default:
1234       // Not supported or invalid event.
1235       NOTREACHED();
1236       return -1;
1237   }
1238 }
1239
1240 int32 NativeViewAccessibilityWin::MSAARole(ui::AXRole role) {
1241   switch (role) {
1242     case ui::AX_ROLE_ALERT:
1243       return ROLE_SYSTEM_ALERT;
1244     case ui::AX_ROLE_APPLICATION:
1245       return ROLE_SYSTEM_APPLICATION;
1246     case ui::AX_ROLE_BUTTON_DROP_DOWN:
1247       return ROLE_SYSTEM_BUTTONDROPDOWN;
1248     case ui::AX_ROLE_POP_UP_BUTTON:
1249       return ROLE_SYSTEM_BUTTONMENU;
1250     case ui::AX_ROLE_CHECK_BOX:
1251       return ROLE_SYSTEM_CHECKBUTTON;
1252     case ui::AX_ROLE_COMBO_BOX:
1253       return ROLE_SYSTEM_COMBOBOX;
1254     case ui::AX_ROLE_DIALOG:
1255       return ROLE_SYSTEM_DIALOG;
1256     case ui::AX_ROLE_GROUP:
1257       return ROLE_SYSTEM_GROUPING;
1258     case ui::AX_ROLE_IMAGE:
1259       return ROLE_SYSTEM_GRAPHIC;
1260     case ui::AX_ROLE_LINK:
1261       return ROLE_SYSTEM_LINK;
1262     case ui::AX_ROLE_LOCATION_BAR:
1263       return ROLE_SYSTEM_GROUPING;
1264     case ui::AX_ROLE_MENU_BAR:
1265       return ROLE_SYSTEM_MENUBAR;
1266     case ui::AX_ROLE_MENU_ITEM:
1267       return ROLE_SYSTEM_MENUITEM;
1268     case ui::AX_ROLE_MENU_LIST_POPUP:
1269       return ROLE_SYSTEM_MENUPOPUP;
1270     case ui::AX_ROLE_TREE:
1271       return ROLE_SYSTEM_OUTLINE;
1272     case ui::AX_ROLE_TREE_ITEM:
1273       return ROLE_SYSTEM_OUTLINEITEM;
1274     case ui::AX_ROLE_TAB:
1275       return ROLE_SYSTEM_PAGETAB;
1276     case ui::AX_ROLE_TAB_LIST:
1277       return ROLE_SYSTEM_PAGETABLIST;
1278     case ui::AX_ROLE_PANE:
1279       return ROLE_SYSTEM_PANE;
1280     case ui::AX_ROLE_PROGRESS_INDICATOR:
1281       return ROLE_SYSTEM_PROGRESSBAR;
1282     case ui::AX_ROLE_BUTTON:
1283       return ROLE_SYSTEM_PUSHBUTTON;
1284     case ui::AX_ROLE_RADIO_BUTTON:
1285       return ROLE_SYSTEM_RADIOBUTTON;
1286     case ui::AX_ROLE_SCROLL_BAR:
1287       return ROLE_SYSTEM_SCROLLBAR;
1288     case ui::AX_ROLE_SPLITTER:
1289       return ROLE_SYSTEM_SEPARATOR;
1290     case ui::AX_ROLE_SLIDER:
1291       return ROLE_SYSTEM_SLIDER;
1292     case ui::AX_ROLE_STATIC_TEXT:
1293       return ROLE_SYSTEM_STATICTEXT;
1294     case ui::AX_ROLE_TEXT_FIELD:
1295       return ROLE_SYSTEM_TEXT;
1296     case ui::AX_ROLE_TITLE_BAR:
1297       return ROLE_SYSTEM_TITLEBAR;
1298     case ui::AX_ROLE_TOOLBAR:
1299       return ROLE_SYSTEM_TOOLBAR;
1300     case ui::AX_ROLE_WINDOW:
1301       return ROLE_SYSTEM_WINDOW;
1302     case ui::AX_ROLE_CLIENT:
1303     default:
1304       // This is the default role for MSAA.
1305       return ROLE_SYSTEM_CLIENT;
1306   }
1307 }
1308
1309 int32 NativeViewAccessibilityWin::MSAAState(const ui::AXViewState& state) {
1310   // This maps MSAA states for get_accState(). See also the IAccessible2
1311   // interface get_states().
1312
1313   int32 msaa_state = 0;
1314   if (state.HasStateFlag(ui::AX_STATE_CHECKED))
1315     msaa_state |= STATE_SYSTEM_CHECKED;
1316   if (state.HasStateFlag(ui::AX_STATE_COLLAPSED))
1317     msaa_state |= STATE_SYSTEM_COLLAPSED;
1318   if (state.HasStateFlag(ui::AX_STATE_DEFAULT))
1319     msaa_state |= STATE_SYSTEM_DEFAULT;
1320   if (state.HasStateFlag(ui::AX_STATE_EXPANDED))
1321     msaa_state |= STATE_SYSTEM_EXPANDED;
1322   if (state.HasStateFlag(ui::AX_STATE_HASPOPUP))
1323     msaa_state |= STATE_SYSTEM_HASPOPUP;
1324   if (state.HasStateFlag(ui::AX_STATE_HOVERED))
1325     msaa_state |= STATE_SYSTEM_HOTTRACKED;
1326   if (state.HasStateFlag(ui::AX_STATE_INVISIBLE))
1327     msaa_state |= STATE_SYSTEM_INVISIBLE;
1328   if (state.HasStateFlag(ui::AX_STATE_LINKED))
1329     msaa_state |= STATE_SYSTEM_LINKED;
1330   if (state.HasStateFlag(ui::AX_STATE_OFFSCREEN))
1331     msaa_state |= STATE_SYSTEM_OFFSCREEN;
1332   if (state.HasStateFlag(ui::AX_STATE_PRESSED))
1333     msaa_state |= STATE_SYSTEM_PRESSED;
1334   if (state.HasStateFlag(ui::AX_STATE_PROTECTED))
1335     msaa_state |= STATE_SYSTEM_PROTECTED;
1336   if (state.HasStateFlag(ui::AX_STATE_READ_ONLY))
1337     msaa_state |= STATE_SYSTEM_READONLY;
1338   if (state.HasStateFlag(ui::AX_STATE_SELECTED))
1339     msaa_state |= STATE_SYSTEM_SELECTED;
1340   if (state.HasStateFlag(ui::AX_STATE_FOCUSED))
1341     msaa_state |= STATE_SYSTEM_FOCUSED;
1342   if (state.HasStateFlag(ui::AX_STATE_DISABLED))
1343     msaa_state |= STATE_SYSTEM_UNAVAILABLE;
1344   return msaa_state;
1345 }
1346
1347 //
1348 // Private methods.
1349 //
1350
1351 bool NativeViewAccessibilityWin::IsNavDirNext(int nav_dir) const {
1352   return (nav_dir == NAVDIR_RIGHT ||
1353           nav_dir == NAVDIR_DOWN ||
1354           nav_dir == NAVDIR_NEXT);
1355 }
1356
1357 bool NativeViewAccessibilityWin::IsValidNav(
1358     int nav_dir, int start_id, int lower_bound, int upper_bound) const {
1359   if (IsNavDirNext(nav_dir)) {
1360     if ((start_id + 1) > upper_bound) {
1361       return false;
1362     }
1363   } else {
1364     if ((start_id - 1) <= lower_bound) {
1365       return false;
1366     }
1367   }
1368   return true;
1369 }
1370
1371 bool NativeViewAccessibilityWin::IsValidId(const VARIANT& child) const {
1372   // View accessibility returns an IAccessible for each view so we only support
1373   // the CHILDID_SELF id.
1374   return (VT_I4 == child.vt) && (CHILDID_SELF == child.lVal);
1375 }
1376
1377 void NativeViewAccessibilityWin::SetState(
1378     VARIANT* msaa_state, View* view) {
1379   // Ensure the output param is initialized to zero.
1380   msaa_state->lVal = 0;
1381
1382   // Default state; all views can have accessibility focus.
1383   msaa_state->lVal |= STATE_SYSTEM_FOCUSABLE;
1384
1385   if (!view)
1386     return;
1387
1388   if (!view->enabled())
1389     msaa_state->lVal |= STATE_SYSTEM_UNAVAILABLE;
1390   if (!view->visible())
1391     msaa_state->lVal |= STATE_SYSTEM_INVISIBLE;
1392   if (!strcmp(view->GetClassName(), CustomButton::kViewClassName)) {
1393     CustomButton* button = static_cast<CustomButton*>(view);
1394     if (button->IsHotTracked())
1395       msaa_state->lVal |= STATE_SYSTEM_HOTTRACKED;
1396   }
1397   if (view->HasFocus())
1398     msaa_state->lVal |= STATE_SYSTEM_FOCUSED;
1399
1400   // Add on any view-specific states.
1401   ui::AXViewState view_state;
1402   view->GetAccessibleState(&view_state);
1403   msaa_state->lVal |= MSAAState(view_state);
1404 }
1405
1406 base::string16 NativeViewAccessibilityWin::TextForIAccessibleText() {
1407   ui::AXViewState state;
1408   view_->GetAccessibleState(&state);
1409   if (state.role == ui::AX_ROLE_TEXT_FIELD)
1410     return state.value;
1411   else
1412     return state.name;
1413 }
1414
1415 void NativeViewAccessibilityWin::HandleSpecialTextOffset(
1416     const base::string16& text, LONG* offset) {
1417   if (*offset == IA2_TEXT_OFFSET_LENGTH) {
1418     *offset = static_cast<LONG>(text.size());
1419   } else if (*offset == IA2_TEXT_OFFSET_CARET) {
1420     get_caretOffset(offset);
1421   }
1422 }
1423
1424 ui::TextBoundaryType NativeViewAccessibilityWin::IA2TextBoundaryToTextBoundary(
1425     IA2TextBoundaryType ia2_boundary) {
1426   switch(ia2_boundary) {
1427     case IA2_TEXT_BOUNDARY_CHAR: return ui::CHAR_BOUNDARY;
1428     case IA2_TEXT_BOUNDARY_WORD: return ui::WORD_BOUNDARY;
1429     case IA2_TEXT_BOUNDARY_LINE: return ui::LINE_BOUNDARY;
1430     case IA2_TEXT_BOUNDARY_SENTENCE: return ui::SENTENCE_BOUNDARY;
1431     case IA2_TEXT_BOUNDARY_PARAGRAPH: return ui::PARAGRAPH_BOUNDARY;
1432     case IA2_TEXT_BOUNDARY_ALL: return ui::ALL_BOUNDARY;
1433     default:
1434       NOTREACHED();
1435       return ui::CHAR_BOUNDARY;
1436   }
1437 }
1438
1439 LONG NativeViewAccessibilityWin::FindBoundary(
1440     const base::string16& text,
1441     IA2TextBoundaryType ia2_boundary,
1442     LONG start_offset,
1443     ui::TextBoundaryDirection direction) {
1444   HandleSpecialTextOffset(text, &start_offset);
1445   ui::TextBoundaryType boundary = IA2TextBoundaryToTextBoundary(ia2_boundary);
1446   std::vector<int32> line_breaks;
1447   return ui::FindAccessibleTextBoundary(
1448       text, line_breaks, boundary, start_offset, direction);
1449 }
1450
1451 void NativeViewAccessibilityWin::PopulateChildWidgetVector(
1452     std::vector<Widget*>* result_child_widgets) {
1453   const Widget* widget = view()->GetWidget();
1454   if (!widget)
1455     return;
1456
1457   std::set<Widget*> child_widgets;
1458   Widget::GetAllChildWidgets(widget->GetNativeView(), &child_widgets);
1459   Widget::GetAllOwnedWidgets(widget->GetNativeView(), &child_widgets);
1460   for (std::set<Widget*>::const_iterator iter = child_widgets.begin();
1461            iter != child_widgets.end(); ++iter) {
1462     Widget* child_widget = *iter;
1463     if (child_widget == widget)
1464       continue;
1465
1466     if (!child_widget->IsVisible())
1467       continue;
1468
1469     if (widget->GetNativeWindowProperty(kWidgetNativeViewHostKey))
1470       continue;
1471
1472     result_child_widgets->push_back(child_widget);
1473   }
1474 }
1475
1476 void NativeViewAccessibilityWin::AddAlertTarget() {
1477   ViewStorage* view_storage = ViewStorage::GetInstance();
1478   for (size_t i = 0; i < alert_target_view_storage_ids_.size(); ++i) {
1479     int view_storage_id = alert_target_view_storage_ids_[i];
1480     View* view = view_storage->RetrieveView(view_storage_id);
1481     if (view == view_)
1482       return;
1483   }
1484   int view_storage_id = view_storage->CreateStorageID();
1485   view_storage->StoreView(view_storage_id, view_);
1486   alert_target_view_storage_ids_.push_back(view_storage_id);
1487 }
1488
1489 void NativeViewAccessibilityWin::RemoveAlertTarget() {
1490   ViewStorage* view_storage = ViewStorage::GetInstance();
1491   size_t i = 0;
1492   while (i < alert_target_view_storage_ids_.size()) {
1493     int view_storage_id = alert_target_view_storage_ids_[i];
1494     View* view = view_storage->RetrieveView(view_storage_id);
1495     if (view == NULL || view == view_) {
1496       alert_target_view_storage_ids_.erase(
1497           alert_target_view_storage_ids_.begin() + i);
1498     } else {
1499       ++i;
1500     }
1501   }
1502 }
1503
1504 }  // namespace views