Make the selection start and end attributes of an html input control...

chrome/browser/browser_accessibility_win.cc

 // Copyright (c) 2010 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 "chrome/browser/browser_accessibility_win.h"
 
 #include "base/logging.h"
+#include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_accessibility_manager_win.h"
 #include "net/base/escape.h"
 
 using webkit_glue::WebAccessibility;
 
 BrowserAccessibility::BrowserAccessibility()
     : manager_(NULL),
       parent_(NULL),
       child_id_(-1),
       index_in_parent_(-1),
       renderer_id_(-1),
       instance_active_(false) {
 }
 
 BrowserAccessibility::~BrowserAccessibility() {
   InactivateTree();
 }
 
 void BrowserAccessibility::Initialize(
     BrowserAccessibilityManager* manager,
     BrowserAccessibility* parent,
     LONG child_id,
     LONG index_in_parent,
     const webkit_glue::WebAccessibility& src) {
-  DCHECK_EQ(children_.size(), 0U);
-
   manager_ = manager;
   parent_ = parent;
   child_id_ = child_id;
   index_in_parent_ = index_in_parent;
 
   renderer_id_ = src.id;
   name_ = src.name;
   value_ = src.value;
   attributes_ = src.attributes;
   html_attributes_ = src.html_attributes;
   location_ = src.location;
+  src_role_ = src.role;
   InitRoleAndState(src.role, src.state);
 
   // Expose headings levels to NVDA with the "level" object attribute.
   if (src.role == WebAccessibility::ROLE_HEADING && role_name_.size() == 2 &&
           IsAsciiDigit(role_name_[1])) {
     html_attributes_.push_back(std::make_pair(L"level", role_name_.substr(1)));
   }
 
   // If this object doesn't have a name but it does have a description,
   // use the description as its name - because some screen readers only
@@ skipping 42 matching lines @@
 }
 
 BrowserAccessibility* BrowserAccessibility::GetParent() {
   return parent_;
 }
 
 uint32 BrowserAccessibility::GetChildCount() {
   return children_.size();
 }
 
+BrowserAccessibility* BrowserAccessibility::GetChild(uint32 child_index) {
+  DCHECK(child_index >= 0 && child_index < children_.size());
+  return children_[child_index];
+}
+
 BrowserAccessibility* BrowserAccessibility::GetPreviousSibling() {
   if (parent_ && index_in_parent_ > 0)
     return parent_->children_[index_in_parent_ - 1];
 
   return NULL;
 }
 
 BrowserAccessibility* BrowserAccessibility::GetNextSibling() {
   if (parent_ &&
       index_in_parent_ >= 0 &&
@@ skipping 449 matching lines @@
   if (!instance_active_)
     return E_FAIL;
 
   if (!desc)
     return E_INVALIDARG;
 
   return GetAttributeAsBstr(WebAccessibility::ATTR_DESCRIPTION, desc);
 }
 
 STDMETHODIMP BrowserAccessibility::get_imagePosition(
-    enum IA2CoordinateType coordinate_type, long* x, long* y) {
+    enum IA2CoordinateType coordinate_type, LONG* x, LONG* y) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!x || !y)
     return E_INVALIDARG;
 
   if (coordinate_type == IA2_COORDTYPE_SCREEN_RELATIVE) {
     HWND parent_hwnd = manager_->GetParentHWND();
     POINT top_left = {0, 0};
     ::ClientToScreen(parent_hwnd, &top_left);
     *x = location_.x + top_left.x;
     *y = location_.y + top_left.y;
   } else if (coordinate_type == IA2_COORDTYPE_PARENT_RELATIVE) {
     *x = location_.x;
     *y = location_.y;
     if (parent_) {
       *x -= parent_->location_.x;
       *y -= parent_->location_.y;
     }
   } else {
     return E_INVALIDARG;
   }
 
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibility::get_imageSize(long* height, long* width) {
+STDMETHODIMP BrowserAccessibility::get_imageSize(LONG* height, LONG* width) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!height || !width)
     return E_INVALIDARG;
 
   *height = location_.height;
   *width = location_.width;
   return S_OK;
 }
 
 //
 // IAccessibleText methods.
 //
 
-STDMETHODIMP BrowserAccessibility::get_nCharacters(long* n_characters) {
+STDMETHODIMP BrowserAccessibility::get_nCharacters(LONG* n_characters) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!n_characters)
     return E_INVALIDARG;
 
-  *n_characters = name_.length();
+  if (src_role_ == WebAccessibility::ROLE_TEXT_FIELD) {
+    *n_characters = value_.length();
+  } else {
+    *n_characters = name_.length();
+  }
+
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibility::get_text(
-    long start_offset, long end_offset, BSTR* text) {
+    LONG start_offset, LONG end_offset, BSTR* text) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!text)
     return E_INVALIDARG;
 
-  long len = name_.length();
+  string16 text_str;

[Chris Guillory, 2010/10/01 18:06:43]

Can we use a reference here.

+  if (src_role_ == WebAccessibility::ROLE_TEXT_FIELD) {
+    text_str = value_;
+  } else {
+    text_str = name_;
+  }
+
+  // The spec allows the arguments to be reversed.
+  if (start_offset > end_offset) {
+    LONG tmp = start_offset;
+    start_offset = end_offset;
+    end_offset = tmp;
+  }
+
+  // The spec does not allow the start or end offsets to be out or range;
+  // we must return an error if so.
+  LONG len = text_str.length();
   if (start_offset < 0)
-    start_offset = 0;
+    return E_INVALIDARG;
   if (end_offset > len)
-    end_offset = len;
+    return E_INVALIDARG;
 
-  string16 substr = name_.substr(start_offset, end_offset - start_offset);
+  string16 substr = text_str.substr(start_offset, end_offset - start_offset);
   if (substr.empty())
     return S_FALSE;
 
   *text = SysAllocString(substr.c_str());
   DCHECK(*text);
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibility::get_caretOffset(long* offset) {
+STDMETHODIMP BrowserAccessibility::get_caretOffset(LONG* offset) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!offset)
     return E_INVALIDARG;
 
-  *offset = 0;
+  if (src_role_ == WebAccessibility::ROLE_TEXT_FIELD) {
+    int sel_start = 0;
+    if (GetAttributeAsInt(WebAccessibility::ATTR_TEXT_SEL_START, &sel_start)) {
+      *offset = sel_start;
+    } else {
+      *offset = 0;
+    }
+  } else {
+    *offset = 0;
+  }
+
+  return S_OK;
+}
+
+STDMETHODIMP BrowserAccessibility::get_nSelections(LONG* n_selections) {
+  if (!instance_active_)
+    return E_FAIL;
+
+  if (!n_selections)
+    return E_INVALIDARG;
+
+  if (src_role_ == WebAccessibility::ROLE_TEXT_FIELD) {
+    int sel_start = 0;
+    int sel_end = 0;
+    if (GetAttributeAsInt(WebAccessibility::ATTR_TEXT_SEL_START, &sel_start) &&
+        GetAttributeAsInt(WebAccessibility::ATTR_TEXT_SEL_END, &sel_end) &&
+        sel_start != sel_end) {
+      *n_selections = 1;
+    } else {
+      *n_selections = 0;
+    }
+  } else {
+    *n_selections = 0;
+  }
+
+  return S_OK;
+}
+
+STDMETHODIMP BrowserAccessibility::get_selection(LONG selection_index,
+                                                 LONG* start_offset,
+                                                 LONG* end_offset) {
+  if (!instance_active_)
+    return E_FAIL;
+
+  if (!start_offset || !end_offset || selection_index != 0)
+    return E_INVALIDARG;
+
+  if (src_role_ == WebAccessibility::ROLE_TEXT_FIELD) {
+    int sel_start = 0;
+    int sel_end = 0;
+    if (GetAttributeAsInt(WebAccessibility::ATTR_TEXT_SEL_START, &sel_start) &&
+        GetAttributeAsInt(WebAccessibility::ATTR_TEXT_SEL_END, &sel_end)) {
+      *start_offset = sel_start;
+      *end_offset = sel_end;
+    } else {
+      *start_offset = 0;
+      *end_offset = 0;
+    }
+  } else {
+    *start_offset = 0;
+    *end_offset = 0;
+  }
+
   return S_OK;
 }
 
 //
 // ISimpleDOMDocument methods.
 //
 
 STDMETHODIMP BrowserAccessibility::get_URL(BSTR* url) {
   if (!instance_active_)
     return E_FAIL;
@@ skipping 331 matching lines @@
 //
 // CComObjectRootEx methods.
 //
 
 HRESULT WINAPI BrowserAccessibility::InternalQueryInterface(
     void* this_ptr,
     const _ATL_INTMAP_ENTRY* entries,
     REFIID iid,
     void** object) {
   if (iid == IID_IAccessibleText) {
-    if (role_ != ROLE_SYSTEM_LINK) {
+    if (role_ != ROLE_SYSTEM_LINK && role_ != ROLE_SYSTEM_TEXT) {
       *object = NULL;
       return E_NOINTERFACE;
     }
   } else if (iid == IID_IAccessibleImage) {
     if (role_ != ROLE_SYSTEM_GRAPHIC) {
       *object = NULL;
       return E_NOINTERFACE;
     }
   } else if (iid == IID_ISimpleDOMDocument) {
     if (role_ != ROLE_SYSTEM_DOCUMENT) {
@@ skipping 49 matching lines @@
 
   if (str.empty())
     return S_FALSE;
 
   *value_bstr = SysAllocString(str.c_str());
   DCHECK(*value_bstr);
 
   return S_OK;
 }
 
-string16 BrowserAccessibility::Escape(string16 str) {
-  return UTF8ToUTF16(EscapeNonASCII(UTF16ToUTF8(str)));
+bool BrowserAccessibility::GetAttributeAsInt(
+    WebAccessibility::Attribute attribute, int* value_int) {
+  string16 value_str;
+
+  if (!GetAttribute(attribute, &value_str))
+    return false;
+
+  if (!base::StringToInt(value_str, value_int))
+    return false;
+
+  return true;
 }
 
-void BrowserAccessibility::InitRoleAndState(LONG web_role,
-                                            LONG web_state) {
+string16 BrowserAccessibility::Escape(string16 str) {
+  return EscapeQueryParamValueUTF8(str, false);
+}
+
+void BrowserAccessibility::InitRoleAndState(LONG web_role, LONG web_state) {
   state_ = 0;
   ia2_state_ = IA2_STATE_OPAQUE;
 
   if ((web_state >> WebAccessibility::STATE_CHECKED) & 1)
     state_ |= STATE_SYSTEM_CHECKED;
   if ((web_state >> WebAccessibility::STATE_COLLAPSED) & 1)
     state_ |= STATE_SYSTEM_COLLAPSED;
   if ((web_state >> WebAccessibility::STATE_EXPANDED) & 1)
     state_ |= STATE_SYSTEM_EXPANDED;
   if ((web_state >> WebAccessibility::STATE_FOCUSABLE) & 1)
@@ skipping 277 matching lines @@
   }
 
   // The role should always be set.
   DCHECK(!role_name_.empty() || role_);
 
   // If we didn't explicitly set the IAccessible2 role, make it the same
   // as the MSAA role.
   if (!ia2_role_)
     ia2_role_ = role_;
 }