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