Relanding http://codereview.chromium.org/8416034

content/browser/accessibility/browser_accessibility_win.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/accessibility/browser_accessibility_win.h"
 
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/scoped_comptr.h"
 #include "content/browser/accessibility/browser_accessibility_manager_win.h"
 #include "content/common/view_messages.h"
 #include "net/base/escape.h"
 #include "ui/base/accessibility/accessible_text_utils.h"
 
 using webkit_glue::WebAccessibility;
 
 // The GUID for the ISimpleDOM service is not defined in the IDL files.
 // This is taken directly from the Mozilla sources
 // (accessible/src/msaa/nsAccessNodeWrap.cpp) and it's also documented at:
 // http://developer.mozilla.org/en/Accessibility/AT-APIs/ImplementationFeatures/MSAA
 
 const GUID GUID_ISimpleDOM = {
     0x0c539790, 0x12e4, 0x11cf,
     0xb6, 0x61, 0x00, 0xaa, 0x00, 0x4c, 0xd6, 0xd8};
 
+const char16 BrowserAccessibilityWin::kEmbeddedCharacter[] = L"\xfffc";
+
 //
 // BrowserAccessibilityRelation
 //
 // A simple implementation of IAccessibleRelation, used to represent
 // a relationship between two accessible nodes in the tree.
 //
 
 class BrowserAccessibilityRelation
     : public CComObjectRootEx<CComMultiThreadModel>,
       public IAccessibleRelation {
@@ skipping 1557 matching lines @@
 // IAccessibleText methods.
 //
 
 STDMETHODIMP BrowserAccessibilityWin::get_nCharacters(LONG* n_characters) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!n_characters)
     return E_INVALIDARG;
 
-  if (role_ == WebAccessibility::ROLE_TEXT_FIELD ||
-      role_ == WebAccessibility::ROLE_TEXTAREA) {
-    *n_characters = value_.length();
-  } else {
-    *n_characters = name_.length();
-  }
-
+  *n_characters = TextForIAccessibleText().length();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_caretOffset(LONG* offset) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!offset)
     return E_INVALIDARG;
 
@@ skipping 226 matching lines @@
     return E_INVALIDARG;
 
   // TODO(dmazzoni): implement this. We're returning S_OK for now so that
   // screen readers still return partially accurate results rather than
   // completely failing.
   *offset = 0;
   return S_OK;
 }
 
 //
+// IAccessibleHypertext methods.
+//
+
+STDMETHODIMP BrowserAccessibilityWin::get_nHyperlinks(long* hyperlink_count) {
+  if (!instance_active_)
+    return E_FAIL;
+
+  if (!hyperlink_count)
+    return E_INVALIDARG;
+
+  *hyperlink_count = hyperlink_offset_to_index_.size();
+  return S_OK;
+}
+
+STDMETHODIMP BrowserAccessibilityWin::get_hyperlink(
+    long index,
+    IAccessibleHyperlink** hyperlink) {
+  if (!instance_active_)
+    return E_FAIL;
+
+  if (!hyperlink ||
+      index < 0 ||
+      index >= static_cast<long>(hyperlinks_.size())) {
+    return E_INVALIDARG;
+  }
+
+  BrowserAccessibilityWin* child =
+      children_[hyperlinks_[index]]->toBrowserAccessibilityWin();
+  *hyperlink = static_cast<IAccessibleHyperlink*>(child->NewReference());
+  return S_OK;
+}
+
+STDMETHODIMP BrowserAccessibilityWin::get_hyperlinkIndex(
+    long char_index,
+    long* hyperlink_index) {
+  if (!instance_active_)
+    return E_FAIL;
+
+  if (!hyperlink_index)
+    return E_INVALIDARG;
+
+  *hyperlink_index = -1;
+
+  if (char_index < 0 || char_index >= static_cast<long>(hypertext_.size()))
+    return E_INVALIDARG;
+
+  std::map<int32, int32>::iterator it =
+      hyperlink_offset_to_index_.find(char_index);
+  if (it == hyperlink_offset_to_index_.end())
+    return E_FAIL;
+
+  *hyperlink_index = it->second;
+  return S_OK;
+}
+
+//
 // IAccessibleValue methods.
 //
 
 STDMETHODIMP BrowserAccessibilityWin::get_currentValue(VARIANT* value) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!value)
     return E_INVALIDARG;
 
@@ skipping 373 matching lines @@
 // IServiceProvider methods.
 //
 
 STDMETHODIMP BrowserAccessibilityWin::QueryService(
     REFGUID guidService, REFIID riid, void** object) {
   if (!instance_active_)
     return E_FAIL;
 
   if (guidService == IID_IAccessible ||
       guidService == IID_IAccessible2 ||
+      guidService == IID_IAccessibleAction ||
+      guidService == IID_IAccessibleHyperlink ||
+      guidService == IID_IAccessibleHypertext ||
       guidService == IID_IAccessibleImage ||
       guidService == IID_IAccessibleTable ||
       guidService == IID_IAccessibleTable2 ||
       guidService == IID_IAccessibleTableCell ||
       guidService == IID_IAccessibleText ||
       guidService == IID_IAccessibleValue ||
       guidService == IID_ISimpleDOMDocument ||
       guidService == IID_ISimpleDOMNode ||
       guidService == IID_ISimpleDOMText ||
       guidService == GUID_ISimpleDOM) {
     return QueryInterface(riid, object);
   }
 
   *object = NULL;
   return E_FAIL;
 }
 
 //
 // CComObjectRootEx methods.
 //
 
 HRESULT WINAPI BrowserAccessibilityWin::InternalQueryInterface(
     void* this_ptr,
     const _ATL_INTMAP_ENTRY* entries,
     REFIID iid,
     void** object) {
-  if (iid == IID_IAccessibleText) {
-    if (ia_role_ != ROLE_SYSTEM_LINK && ia_role_ != ROLE_SYSTEM_TEXT) {
-      *object = NULL;
-      return E_NOINTERFACE;
-    }
-  } else if (iid == IID_IAccessibleImage) {
+  if (iid == IID_IAccessibleImage) {
     if (ia_role_ != ROLE_SYSTEM_GRAPHIC) {
       *object = NULL;
       return E_NOINTERFACE;
     }
   } else if (iid == IID_IAccessibleTable || iid == IID_IAccessibleTable2) {
     if (ia_role_ != ROLE_SYSTEM_TABLE) {
       *object = NULL;
       return E_NOINTERFACE;
     }
   } else if (iid == IID_IAccessibleTableCell) {
@@ skipping 17 matching lines @@
 
   return CComObjectRootBase::InternalQueryInterface(
       this_ptr, entries, iid, object);
 }
 
 //
 // Private methods.
 //
 
 // Initialize this object and mark it as active.
-void BrowserAccessibilityWin::Initialize() {
-  BrowserAccessibility::Initialize();
+void BrowserAccessibilityWin::PreInitialize() {
+  BrowserAccessibility::PreInitialize();
 
   InitRoleAndState();
 
   // Expose headings levels with the "level" attribute.
   if (role_ == WebAccessibility::ROLE_HEADING && role_name_.size() == 2 &&
           IsAsciiDigit(role_name_[1])) {
     ia2_attributes_.push_back(string16(L"level:") + role_name_.substr(1));
   }
 
   // Expose the "display" and "tag" attributes.
@@ skipping 86 matching lines @@
     HRESULT hr = CComObject<BrowserAccessibilityRelation>::CreateInstance(
         &relation);
     DCHECK(SUCCEEDED(hr));
     relation->AddRef();
     relation->Initialize(this, IA2_RELATION_LABELLED_BY);
     relation->AddTarget(title_elem_id);
     relations_.push_back(relation);
   }
 }
 
-void BrowserAccessibilityWin::SendNodeUpdateEvents() {
+void BrowserAccessibilityWin::PostInitialize() {
+  BrowserAccessibility::PostInitialize();
+
+  // Construct the hypertext for this node.
+  hyperlink_offset_to_index_.clear();
+  hyperlinks_.clear();
+  hypertext_.clear();
+  for (unsigned int i = 0; i < children().size(); ++i) {
+    BrowserAccessibility* child = children()[i];
+    if (child->role() == WebAccessibility::ROLE_STATIC_TEXT) {
+      hypertext_ += child->name();
+    } else {
+      hyperlink_offset_to_index_[hypertext_.size()] = hyperlinks_.size();
+      hypertext_ += kEmbeddedCharacter;
+      hyperlinks_.push_back(i);
+    }
+  }
+  DCHECK_EQ(hyperlink_offset_to_index_.size(), hyperlinks_.size());
+
   // Fire an event when an alert first appears.
   if (role_ == WebAccessibility::ROLE_ALERT && first_time_)
     manager_->NotifyAccessibilityEvent(ViewHostMsg_AccEvent::ALERT, this);
 
   // Fire events if text has changed.
   string16 text = TextForIAccessibleText();
   if (previous_text_ != text) {
     if (!previous_text_.empty() && !text.empty()) {
       manager_->NotifyAccessibilityEvent(
           ViewHostMsg_AccEvent::OBJECT_SHOW, this);
@@ skipping 76 matching lines @@
                               base::IntToString16(value));
 }
 
 string16 BrowserAccessibilityWin::Escape(const string16& str) {
   return net::EscapeQueryParamValueUTF8(str, false);
 }
 
 const string16& BrowserAccessibilityWin::TextForIAccessibleText() {
   if (IsEditableText()) {
     return value_;
+  } else if (role_ == WebAccessibility::ROLE_STATIC_TEXT) {
+    return name_;
   } else {
-    return name_;
+    return hypertext_;
   }
 }
 
 void BrowserAccessibilityWin::HandleSpecialTextOffset(
     const string16& text, LONG* offset) {
   if (*offset == IA2_TEXT_OFFSET_LENGTH) {
     *offset = static_cast<LONG>(text.size());
   } else if (*offset == IA2_TEXT_OFFSET_CARET) {
     get_caretOffset(offset);
   }
@@ skipping 430 matching lines @@
   }
 
   // The role should always be set.
   DCHECK(!role_name_.empty() || ia_role_);
 
   // If we didn't explicitly set the IAccessible2 role, make it the same
   // as the MSAA role.
   if (!ia2_role_)
     ia2_role_ = ia_role_;
 }