Make BrowserAccessibilityManager cross platform. Step 1....

chrome/browser/accessibility/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 "chrome/browser/accessibility/browser_accessibility_win.h"
 
-#include "base/logging.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
-#include "chrome/browser/browser_accessibility_manager_win.h"
+#include "chrome/browser/accessibility/browser_accessibility_manager_win.h"
 #include "net/base/escape.h"
 
 using webkit_glue::WebAccessibility;
 
-BrowserAccessibility::BrowserAccessibility()
+BrowserAccessibilityWin::BrowserAccessibilityWin()
     : manager_(NULL),
       parent_(NULL),
       child_id_(-1),
       index_in_parent_(-1),
       renderer_id_(-1),
       instance_active_(false) {
 }
 
-BrowserAccessibility::~BrowserAccessibility() {
+BrowserAccessibilityWin::~BrowserAccessibilityWin() {
   InactivateTree();
 }
 
-void BrowserAccessibility::Initialize(
-    BrowserAccessibilityManager* manager,
-    BrowserAccessibility* parent,
+void BrowserAccessibilityWin::Initialize(
+    BrowserAccessibilityManagerWin* manager,
+    BrowserAccessibilityWin* 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;
 
@@ skipping 14 matching lines @@
   // 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
   // announce the name.
   if (name_.empty() && HasAttribute(WebAccessibility::ATTR_DESCRIPTION)) {
     GetAttribute(WebAccessibility::ATTR_DESCRIPTION, &name_);
   }
 
   instance_active_ = true;
 }
 
-void BrowserAccessibility::AddChild(BrowserAccessibility* child) {
+void BrowserAccessibilityWin::AddChild(BrowserAccessibilityWin* child) {
   children_.push_back(child);
 }
 
-void BrowserAccessibility::InactivateTree() {
+void BrowserAccessibilityWin::InactivateTree() {
   if (!instance_active_)
     return;
 
   // Mark this object as inactive, so calls to all COM methods will return
   // failure.
   instance_active_ = false;
 
   // Now we can safely call InactivateTree on our children and remove
   // references to them, so that as much of the tree as possible will be
   // destroyed now - however, nodes that still have references to them
   // might stick around a while until all clients have released them.
-  for (std::vector<BrowserAccessibility*>::iterator iter =
+  for (std::vector<BrowserAccessibilityWin*>::iterator iter =
            children_.begin();
        iter != children_.end(); ++iter) {
     (*iter)->InactivateTree();
     (*iter)->Release();
   }
   children_.clear();
   manager_->Remove(child_id_);
 }
 
-bool BrowserAccessibility::IsDescendantOf(BrowserAccessibility* ancestor) {
+bool BrowserAccessibilityWin::IsDescendantOf(
+    BrowserAccessibilityWin* ancestor) {
   if (this == ancestor) {
     return true;
   } else if (parent_) {
     return parent_->IsDescendantOf(ancestor);
   }
 
   return false;
 }
 
-BrowserAccessibility* BrowserAccessibility::GetParent() {
+BrowserAccessibilityWin* BrowserAccessibilityWin::GetParent() {
   return parent_;
 }
 
-uint32 BrowserAccessibility::GetChildCount() {
+uint32 BrowserAccessibilityWin::GetChildCount() {
   return children_.size();
 }
 
-BrowserAccessibility* BrowserAccessibility::GetPreviousSibling() {
+BrowserAccessibilityWin* BrowserAccessibilityWin::GetPreviousSibling() {
   if (parent_ && index_in_parent_ > 0)
     return parent_->children_[index_in_parent_ - 1];
 
   return NULL;
 }
 
-BrowserAccessibility* BrowserAccessibility::GetNextSibling() {
+BrowserAccessibilityWin* BrowserAccessibilityWin::GetNextSibling() {
   if (parent_ &&
       index_in_parent_ >= 0 &&
       index_in_parent_ < static_cast<int>(parent_->children_.size() - 1)) {
     return parent_->children_[index_in_parent_ + 1];
   }
 
   return NULL;
 }
 
-void BrowserAccessibility::ReplaceChild(
-    const BrowserAccessibility* old_acc, BrowserAccessibility* new_acc) {
+void BrowserAccessibilityWin::ReplaceChild(
+    const BrowserAccessibilityWin* old_acc, BrowserAccessibilityWin* new_acc) {
   DCHECK_EQ(children_[old_acc->index_in_parent_], old_acc);
 
   old_acc = children_[old_acc->index_in_parent_];
   children_[old_acc->index_in_parent_] = new_acc;
 }
 
-BrowserAccessibility* BrowserAccessibility::NewReference() {
+BrowserAccessibilityWin* BrowserAccessibilityWin::NewReference() {
   AddRef();
   return this;
 }
 
 //
 // IAccessible methods.
 //
 // Conventions:
 // * Always test for instance_active_ first and return E_FAIL if it's false.
 // * Always check for invalid arguments first, even if they're unused.
 // * Return S_FALSE if the only output is a string argument and it's empty.
 //
 
-HRESULT BrowserAccessibility::accDoDefaultAction(VARIANT var_id) {
+HRESULT BrowserAccessibilityWin::accDoDefaultAction(VARIANT var_id) {
   if (!instance_active_)
     return E_FAIL;
 
-  BrowserAccessibility* target = GetTargetFromChildID(var_id);
+  BrowserAccessibilityWin* target = GetTargetFromChildID(var_id);
   if (!target)
     return E_INVALIDARG;
 
   manager_->DoDefaultAction(*target);
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibility::accHitTest(LONG x_left, LONG y_top,
+STDMETHODIMP BrowserAccessibilityWin::accHitTest(LONG x_left, LONG y_top,
                                               VARIANT* child) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!child)
     return E_INVALIDARG;
 
   return E_NOTIMPL;
 }
 
-STDMETHODIMP BrowserAccessibility::accLocation(LONG* x_left, LONG* y_top,
+STDMETHODIMP BrowserAccessibilityWin::accLocation(LONG* x_left, LONG* y_top,
                                                LONG* width, LONG* height,
                                                VARIANT var_id) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!x_left || !y_top || !width || !height)
     return E_INVALIDARG;
 
-  BrowserAccessibility* target = GetTargetFromChildID(var_id);
+  BrowserAccessibilityWin* target = GetTargetFromChildID(var_id);
   if (!target)
     return E_INVALIDARG;
 
   // Find the top left corner of the containing window in screen coords, and
   // adjust the output position by this amount.
-  HWND parent_hwnd = manager_->GetParentHWND();
+  HWND parent_hwnd = manager_->GetParentWindow();
   POINT top_left = {0, 0};
   ::ClientToScreen(parent_hwnd, &top_left);
 
   *x_left = target->location_.x + top_left.x;
   *y_top  = target->location_.y + top_left.y;
   *width  = target->location_.width;
   *height = target->location_.height;
 
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibility::accNavigate(
+STDMETHODIMP BrowserAccessibilityWin::accNavigate(
     LONG nav_dir, VARIANT start, VARIANT* end) {
-  BrowserAccessibility* target = GetTargetFromChildID(start);
+  BrowserAccessibilityWin* target = GetTargetFromChildID(start);
   if (!target)
     return E_INVALIDARG;
 
   if ((nav_dir == NAVDIR_LASTCHILD || nav_dir == NAVDIR_FIRSTCHILD) &&
       start.lVal != CHILDID_SELF) {
     // MSAA states that navigating to first/last child can only be from self.
     return E_INVALIDARG;
   }
 
-  BrowserAccessibility* result = NULL;
+  BrowserAccessibilityWin* result = NULL;
   switch (nav_dir) {
     case NAVDIR_DOWN:
     case NAVDIR_UP:
     case NAVDIR_LEFT:
     case NAVDIR_RIGHT:
       // These directions are not implemented, matching Mozilla and IE.
       return E_NOTIMPL;
     case NAVDIR_FIRSTCHILD:
       if (target->children_.size() > 0)
         result = target->children_[0];
@@ skipping 13 matching lines @@
   if (!result) {
     end->vt = VT_EMPTY;
     return S_FALSE;
   }
 
   end->vt = VT_DISPATCH;
   end->pdispVal = result->NewReference();
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibility::get_accChild(VARIANT var_child,
+STDMETHODIMP BrowserAccessibilityWin::get_accChild(VARIANT var_child,
                                                 IDispatch** disp_child) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!disp_child)
     return E_INVALIDARG;
 
   *disp_child = NULL;
 
-  BrowserAccessibility* target = GetTargetFromChildID(var_child);
+  BrowserAccessibilityWin* target = GetTargetFromChildID(var_child);
   if (!target)
     return E_INVALIDARG;
 
   (*disp_child) = target->NewReference();
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibility::get_accChildCount(LONG* child_count) {
+STDMETHODIMP BrowserAccessibilityWin::get_accChildCount(LONG* child_count) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!child_count)
     return E_INVALIDARG;
 
   *child_count = children_.size();
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibility::get_accDefaultAction(VARIANT var_id,
+STDMETHODIMP BrowserAccessibilityWin::get_accDefaultAction(VARIANT var_id,
                                                         BSTR* def_action) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!def_action)
     return E_INVALIDARG;
 
-  BrowserAccessibility* target = GetTargetFromChildID(var_id);
+  BrowserAccessibilityWin* target = GetTargetFromChildID(var_id);
   if (!target)
     return E_INVALIDARG;
 
   return target->GetAttributeAsBstr(
       WebAccessibility::ATTR_SHORTCUT, def_action);
 }
 
-STDMETHODIMP BrowserAccessibility::get_accDescription(VARIANT var_id,
+STDMETHODIMP BrowserAccessibilityWin::get_accDescription(VARIANT var_id,
                                                       BSTR* desc) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!desc)
     return E_INVALIDARG;
 
-  BrowserAccessibility* target = GetTargetFromChildID(var_id);
+  BrowserAccessibilityWin* target = GetTargetFromChildID(var_id);
   if (!target)
     return E_INVALIDARG;
 
   return target->GetAttributeAsBstr(WebAccessibility::ATTR_DESCRIPTION, desc);
 }
 
-STDMETHODIMP BrowserAccessibility::get_accFocus(VARIANT* focus_child) {
+STDMETHODIMP BrowserAccessibilityWin::get_accFocus(VARIANT* focus_child) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!focus_child)
     return E_INVALIDARG;
 
-  BrowserAccessibility* focus = manager_->GetFocus(this);
+  BrowserAccessibilityWin* focus = static_cast<BrowserAccessibilityWin*>(
+      manager_->GetFocus(this));
   if (focus == this) {
     focus_child->vt = VT_I4;
     focus_child->lVal = CHILDID_SELF;
   } else if (focus == NULL) {
     focus_child->vt = VT_EMPTY;
   } else {
     focus_child->vt = VT_DISPATCH;
     focus_child->pdispVal = focus->NewReference();
   }
 
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibility::get_accHelp(VARIANT var_id, BSTR* help) {
+STDMETHODIMP BrowserAccessibilityWin::get_accHelp(VARIANT var_id, BSTR* help) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!help)
     return E_INVALIDARG;
 
-  BrowserAccessibility* target = GetTargetFromChildID(var_id);
+  BrowserAccessibilityWin* target = GetTargetFromChildID(var_id);
   if (!target)
     return E_INVALIDARG;
 
   return target->GetAttributeAsBstr(WebAccessibility::ATTR_HELP, help);
 }
 
-STDMETHODIMP BrowserAccessibility::get_accKeyboardShortcut(VARIANT var_id,
+STDMETHODIMP BrowserAccessibilityWin::get_accKeyboardShortcut(VARIANT var_id,
                                                            BSTR* acc_key) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!acc_key)
     return E_INVALIDARG;
 
-  BrowserAccessibility* target = GetTargetFromChildID(var_id);
+  BrowserAccessibilityWin* target = GetTargetFromChildID(var_id);
   if (!target)
     return E_INVALIDARG;
 
   return target->GetAttributeAsBstr(WebAccessibility::ATTR_SHORTCUT, acc_key);
 }
 
-STDMETHODIMP BrowserAccessibility::get_accName(VARIANT var_id, BSTR* name) {
+STDMETHODIMP BrowserAccessibilityWin::get_accName(VARIANT var_id, BSTR* name) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!name)
     return E_INVALIDARG;
 
-  BrowserAccessibility* target = GetTargetFromChildID(var_id);
+  BrowserAccessibilityWin* target = GetTargetFromChildID(var_id);
   if (!target)
     return E_INVALIDARG;
 
   if (target->name_.empty())
     return S_FALSE;
 
   *name = SysAllocString(target->name_.c_str());
 
   DCHECK(*name);
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibility::get_accParent(IDispatch** disp_parent) {
+STDMETHODIMP BrowserAccessibilityWin::get_accParent(IDispatch** disp_parent) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!disp_parent)
     return E_INVALIDARG;
 
   IAccessible* parent = parent_;
   if (parent == NULL) {
     // This happens if we're the root of the tree;
     // return the IAccessible for the window.
     parent = manager_->GetParentWindowIAccessible();
   }
 
   parent->AddRef();
   *disp_parent = parent;
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibility::get_accRole(VARIANT var_id, VARIANT* role) {
+STDMETHODIMP BrowserAccessibilityWin::get_accRole(
+    VARIANT var_id, VARIANT* role) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!role)
     return E_INVALIDARG;
 
-  BrowserAccessibility* target = GetTargetFromChildID(var_id);
+  BrowserAccessibilityWin* target = GetTargetFromChildID(var_id);
   if (!target)
     return E_INVALIDARG;
 
   if (!target->role_name_.empty()) {
     role->vt = VT_BSTR;
     role->bstrVal = SysAllocString(target->role_name_.c_str());
   } else {
     role->vt = VT_I4;
     role->lVal = target->role_;
   }
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibility::get_accState(VARIANT var_id,
+STDMETHODIMP BrowserAccessibilityWin::get_accState(VARIANT var_id,
                                                 VARIANT* state) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!state)
     return E_INVALIDARG;
 
-  BrowserAccessibility* target = GetTargetFromChildID(var_id);
+  BrowserAccessibilityWin* target = GetTargetFromChildID(var_id);
   if (!target)
     return E_INVALIDARG;
 
   state->vt = VT_I4;
   state->lVal = target->state_;
   if (manager_->GetFocus(NULL) == this)
     state->lVal |= STATE_SYSTEM_FOCUSED;
 
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibility::get_accValue(VARIANT var_id, BSTR* value) {
+STDMETHODIMP BrowserAccessibilityWin::get_accValue(
+    VARIANT var_id, BSTR* value) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!value)
     return E_INVALIDARG;
 
-  BrowserAccessibility* target = GetTargetFromChildID(var_id);
+  BrowserAccessibilityWin* target = GetTargetFromChildID(var_id);
   if (!target)
     return E_INVALIDARG;
 
   *value = SysAllocString(target->value_.c_str());
 
   DCHECK(*value);
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibility::get_accHelpTopic(BSTR* help_file,
-                                                    VARIANT var_id,
-                                                    LONG* topic_id) {
+STDMETHODIMP BrowserAccessibilityWin::get_accHelpTopic(
+    BSTR* help_file, VARIANT var_id, LONG* topic_id) {
   return E_NOTIMPL;
 }
 
-STDMETHODIMP BrowserAccessibility::get_accSelection(VARIANT* selected) {
+STDMETHODIMP BrowserAccessibilityWin::get_accSelection(VARIANT* selected) {
   if (!instance_active_)
     return E_FAIL;
 
   return E_NOTIMPL;
 }
 
-STDMETHODIMP BrowserAccessibility::accSelect(LONG flags_sel, VARIANT var_id) {
+STDMETHODIMP BrowserAccessibilityWin::accSelect(
+    LONG flags_sel, VARIANT var_id) {
   if (!instance_active_)
     return E_FAIL;
 
   if (flags_sel & SELFLAG_TAKEFOCUS) {
     manager_->SetFocus(*this);
     return S_OK;
   }
 
   return S_FALSE;
 }
 
 //
 // IAccessible2 methods.
 //
 
-STDMETHODIMP BrowserAccessibility::role(LONG* role) {
+STDMETHODIMP BrowserAccessibilityWin::role(LONG* role) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!role)
     return E_INVALIDARG;
 
   *role = ia2_role_;
 
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibility::get_attributes(BSTR* attributes) {
+STDMETHODIMP BrowserAccessibilityWin::get_attributes(BSTR* attributes) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!attributes)
     return E_INVALIDARG;
 
   // Follow Firefox's convention, which is to return a set of key-value pairs
   // separated by semicolons, with a colon between the key and the value.
   string16 str;
   for (unsigned int i = 0; i < html_attributes_.size(); i++) {
     if (i != 0)
       str += L';';
     str += Escape(html_attributes_[i].first);
     str += L':';
     str += Escape(html_attributes_[i].second);
   }
 
   if (str.empty())
     return S_FALSE;
 
   *attributes = SysAllocString(str.c_str());
   DCHECK(*attributes);
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibility::get_states(AccessibleStates* states) {
+STDMETHODIMP BrowserAccessibilityWin::get_states(AccessibleStates* states) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!states)
     return E_INVALIDARG;
 
   *states = ia2_state_;
 
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibility::get_uniqueID(LONG* unique_id) {
+STDMETHODIMP BrowserAccessibilityWin::get_uniqueID(LONG* unique_id) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!unique_id)
     return E_INVALIDARG;
 
   *unique_id = child_id_;
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibility::get_windowHandle(HWND* window_handle) {
+STDMETHODIMP BrowserAccessibilityWin::get_windowHandle(HWND* window_handle) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!window_handle)
     return E_INVALIDARG;
 
-  *window_handle = manager_->GetParentHWND();
+  *window_handle = manager_->GetParentWindow();
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibility::get_indexInParent(LONG* index_in_parent) {
+STDMETHODIMP BrowserAccessibilityWin::get_indexInParent(LONG* index_in_parent) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!index_in_parent)
     return E_INVALIDARG;
 
   *index_in_parent = index_in_parent_;
   return S_OK;
 }
 
 //
 // IAccessibleImage methods.
 //
 
-STDMETHODIMP BrowserAccessibility::get_description(BSTR* desc) {
+STDMETHODIMP BrowserAccessibilityWin::get_description(BSTR* desc) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!desc)
     return E_INVALIDARG;
 
   return GetAttributeAsBstr(WebAccessibility::ATTR_DESCRIPTION, desc);
 }
 
-STDMETHODIMP BrowserAccessibility::get_imagePosition(
+STDMETHODIMP BrowserAccessibilityWin::get_imagePosition(
     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();
+    HWND parent_hwnd = manager_->GetParentWindow();
     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 BrowserAccessibilityWin::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 BrowserAccessibilityWin::get_nCharacters(long* n_characters) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!n_characters)
     return E_INVALIDARG;
 
   *n_characters = name_.length();
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibility::get_text(
+STDMETHODIMP BrowserAccessibilityWin::get_text(
     long start_offset, long end_offset, BSTR* text) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!text)
     return E_INVALIDARG;
 
   long len = name_.length();
   if (start_offset < 0)
     start_offset = 0;
   if (end_offset > len)
     end_offset = len;
 
   string16 substr = name_.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 BrowserAccessibilityWin::get_caretOffset(long* offset) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!offset)
     return E_INVALIDARG;
 
   *offset = 0;
   return S_OK;
 }
 
 //
 // ISimpleDOMDocument methods.
 //
 
-STDMETHODIMP BrowserAccessibility::get_URL(BSTR* url) {
+STDMETHODIMP BrowserAccessibilityWin::get_URL(BSTR* url) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!url)
     return E_INVALIDARG;
 
   return GetAttributeAsBstr(WebAccessibility::ATTR_DOC_URL, url);
 }
 
-STDMETHODIMP BrowserAccessibility::get_title(BSTR* title) {
+STDMETHODIMP BrowserAccessibilityWin::get_title(BSTR* title) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!title)
     return E_INVALIDARG;
 
   return GetAttributeAsBstr(WebAccessibility::ATTR_DOC_TITLE, title);
 }
 
-STDMETHODIMP BrowserAccessibility::get_mimeType(BSTR* mime_type) {
+STDMETHODIMP BrowserAccessibilityWin::get_mimeType(BSTR* mime_type) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!mime_type)
     return E_INVALIDARG;
 
   return GetAttributeAsBstr(WebAccessibility::ATTR_DOC_MIMETYPE, mime_type);
 }
 
-STDMETHODIMP BrowserAccessibility::get_docType(BSTR* doc_type) {
+STDMETHODIMP BrowserAccessibilityWin::get_docType(BSTR* doc_type) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!doc_type)
     return E_INVALIDARG;
 
   return GetAttributeAsBstr(WebAccessibility::ATTR_DOC_DOCTYPE, doc_type);
 }
 
 //
 // ISimpleDOMNode methods.
 //
 
-STDMETHODIMP BrowserAccessibility::get_nodeInfo(
+STDMETHODIMP BrowserAccessibilityWin::get_nodeInfo(
     BSTR* node_name,
     short* name_space_id,
     BSTR* node_value,
     unsigned int* num_children,
     unsigned int* unique_id,
     unsigned short* node_type) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!node_name || !name_space_id || !node_value || !num_children ||
@@ skipping 17 matching lines @@
   } else if (role_ == ROLE_SYSTEM_TEXT &&
              ((ia2_state_ & IA2_STATE_EDITABLE) == 0)) {
     *node_type = NODETYPE_TEXT;
   } else {
     *node_type = NODETYPE_ELEMENT;
   }
 
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibility::get_attributes(
+STDMETHODIMP BrowserAccessibilityWin::get_attributes(
     unsigned short max_attribs,
     BSTR* attrib_names,
     short* name_space_id,
     BSTR* attrib_values,
     unsigned short* num_attribs) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!attrib_names || !name_space_id || !attrib_values || !num_attribs)
     return E_INVALIDARG;
 
   *num_attribs = max_attribs;
   if (*num_attribs > html_attributes_.size())
     *num_attribs = html_attributes_.size();
 
   for (unsigned short i = 0; i < *num_attribs; ++i) {
     attrib_names[i] = SysAllocString(html_attributes_[i].first.c_str());
     name_space_id[i] = 0;
     attrib_values[i] = SysAllocString(html_attributes_[i].second.c_str());
   }
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibility::get_attributesForNames(
+STDMETHODIMP BrowserAccessibilityWin::get_attributesForNames(
     unsigned short num_attribs,
     BSTR* attrib_names,
     short* name_space_id,
     BSTR* attrib_values) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!attrib_names || !name_space_id || !attrib_values)
     return E_INVALIDARG;
 
   for (unsigned short i = 0; i < num_attribs; ++i) {
     name_space_id[i] = 0;
     bool found = false;
     string16 name = (LPCWSTR)attrib_names[i];
     for (unsigned int j = 0;  j < html_attributes_.size(); ++j) {
       if (html_attributes_[j].first == name) {
         attrib_values[i] = SysAllocString(html_attributes_[j].second.c_str());
         found = true;
         break;
       }
     }
     if (!found) {
       attrib_values[i] = NULL;
     }
   }
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibility::get_computedStyle(
+STDMETHODIMP BrowserAccessibilityWin::get_computedStyle(
     unsigned short max_style_properties,
     boolean use_alternate_view,
     BSTR *style_properties,
     BSTR *style_values,
     unsigned short *num_style_properties)  {
   if (!instance_active_)
     return E_FAIL;
 
   if (!style_properties || !style_values)
     return E_INVALIDARG;
 
   // We only cache a single style property for now: DISPLAY
 
   if (max_style_properties == 0 ||
       !HasAttribute(WebAccessibility::ATTR_DISPLAY)) {
     *num_style_properties = 0;
     return S_OK;
   }
 
   string16 display;
   GetAttribute(WebAccessibility::ATTR_DISPLAY, &display);
   *num_style_properties = 1;
   style_properties[0] = SysAllocString(L"display");
   style_values[0] = SysAllocString(display.c_str());
 
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibility::get_computedStyleForProperties(
+STDMETHODIMP BrowserAccessibilityWin::get_computedStyleForProperties(
     unsigned short num_style_properties,
     boolean use_alternate_view,
     BSTR* style_properties,
     BSTR* style_values) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!style_properties || !style_values)
     return E_INVALIDARG;
 
   // We only cache a single style property for now: DISPLAY
 
   for (unsigned short i = 0; i < num_style_properties; i++) {
     string16 name = (LPCWSTR)style_properties[i];
     StringToLowerASCII(&name);
     if (name == L"display") {
       string16 display;
       GetAttribute(WebAccessibility::ATTR_DISPLAY, &display);
       style_values[i] = SysAllocString(display.c_str());
     } else {
       style_values[i] = NULL;
     }
   }
 
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibility::scrollTo(boolean placeTopLeft) {
+STDMETHODIMP BrowserAccessibilityWin::scrollTo(boolean placeTopLeft) {
   return E_NOTIMPL;
 }
 
-STDMETHODIMP BrowserAccessibility::get_parentNode(ISimpleDOMNode** node) {
+STDMETHODIMP BrowserAccessibilityWin::get_parentNode(ISimpleDOMNode** node) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!node)
     return E_INVALIDARG;
 
   *node = parent_->NewReference();
   return S_OK;
 }
 
-STDMETHODIMP BrowserAccessibility::get_firstChild(ISimpleDOMNode** node)  {
+STDMETHODIMP BrowserAccessibilityWin::get_firstChild(ISimpleDOMNode** node)  {
   if (!instance_active_)
     return E_FAIL;
 
   if (!node)
     return E_INVALIDARG;
 
   if (children_.size()) {
     *node = children_[0]->NewReference();
     return S_OK;
   } else {
     *node = NULL;
     return S_FALSE;
   }
 }
 
-STDMETHODIMP BrowserAccessibility::get_lastChild(ISimpleDOMNode** node) {
+STDMETHODIMP BrowserAccessibilityWin::get_lastChild(ISimpleDOMNode** node) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!node)
     return E_INVALIDARG;
 
   if (children_.size()) {
     *node = children_[children_.size() - 1]->NewReference();
     return S_OK;
   } else {
     *node = NULL;
     return S_FALSE;
   }
 }
 
-STDMETHODIMP BrowserAccessibility::get_previousSibling(
+STDMETHODIMP BrowserAccessibilityWin::get_previousSibling(
     ISimpleDOMNode** node) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!node)
     return E_INVALIDARG;
 
   if (parent_ && index_in_parent_ > 0) {
     *node = parent_->children_[index_in_parent_ - 1]->NewReference();
     return S_OK;
   } else {
     *node = NULL;
     return S_FALSE;
   }
 }
 
-STDMETHODIMP BrowserAccessibility::get_nextSibling(ISimpleDOMNode** node) {
+STDMETHODIMP BrowserAccessibilityWin::get_nextSibling(ISimpleDOMNode** node) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!node)
     return E_INVALIDARG;
 
   if (parent_ &&
       index_in_parent_ >= 0 &&
       index_in_parent_ < static_cast<int>(parent_->children_.size()) - 1) {
     *node = parent_->children_[index_in_parent_ + 1]->NewReference();
     return S_OK;
   } else {
     *node = NULL;
     return S_FALSE;
   }
 }
 
-STDMETHODIMP BrowserAccessibility::get_childAt(
+STDMETHODIMP BrowserAccessibilityWin::get_childAt(
     unsigned int child_index,
     ISimpleDOMNode** node) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!node)
     return E_INVALIDARG;
 
   if (child_index < children_.size()) {
     *node = children_[child_index]->NewReference();
     return S_OK;
   } else {
     *node = NULL;
     return S_FALSE;
   }
 }
 
 //
 // ISimpleDOMText methods.
 //
 
-STDMETHODIMP BrowserAccessibility::get_domText(BSTR* dom_text) {
+STDMETHODIMP BrowserAccessibilityWin::get_domText(BSTR* dom_text) {
   if (!instance_active_)
     return E_FAIL;
 
   if (!dom_text)
     return E_INVALIDARG;
 
   if (name_.empty())
     return S_FALSE;
 
   *dom_text = SysAllocString(name_.c_str());
   DCHECK(*dom_text);
   return S_OK;
 }
 
 //
 // IServiceProvider methods.
 //
 
-STDMETHODIMP BrowserAccessibility::QueryService(
+STDMETHODIMP BrowserAccessibilityWin::QueryService(
     REFGUID guidService, REFIID riid, void** object) {
   if (!instance_active_)
     return E_FAIL;
 
   if (guidService == IID_IAccessible ||
       guidService == IID_IAccessible2 ||
       guidService == IID_IAccessibleImage ||
       guidService == IID_IAccessibleText ||
       guidService == IID_ISimpleDOMDocument ||
       guidService == IID_ISimpleDOMNode ||
       guidService == IID_ISimpleDOMText) {
     return QueryInterface(riid, object);
   }
 
   *object = NULL;
   return E_FAIL;
 }
 
 //
 // CComObjectRootEx methods.
 //
 
-HRESULT WINAPI BrowserAccessibility::InternalQueryInterface(
+HRESULT WINAPI BrowserAccessibilityWin::InternalQueryInterface(
     void* this_ptr,
     const _ATL_INTMAP_ENTRY* entries,
     REFIID iid,
     void** object) {
   if (iid == IID_IAccessibleText) {
     if (role_ != ROLE_SYSTEM_LINK) {
       *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) {
       *object = NULL;
       return E_NOINTERFACE;
     }
   }
 
   return CComObjectRootBase::InternalQueryInterface(
       this_ptr, entries, iid, object);
 }
 
 //
 // Private methods.
 //
 
-BrowserAccessibility* BrowserAccessibility::GetTargetFromChildID(
+BrowserAccessibilityWin* BrowserAccessibilityWin::GetTargetFromChildID(
     const VARIANT& var_id) {
   if (var_id.vt != VT_I4)
     return NULL;
 
   LONG child_id = var_id.lVal;
   if (child_id == CHILDID_SELF)
     return this;
 
   if (child_id >= 1 && child_id <= static_cast<LONG>(children_.size()))
     return children_[child_id - 1];
 
   return manager_->GetFromChildID(child_id);
 }
 
-bool BrowserAccessibility::HasAttribute(WebAccessibility::Attribute attribute) {
+bool BrowserAccessibilityWin::HasAttribute(
+    WebAccessibility::Attribute attribute) {
   return (attributes_.find(attribute) != attributes_.end());
 }
 
-bool BrowserAccessibility::GetAttribute(
+bool BrowserAccessibilityWin::GetAttribute(
     WebAccessibility::Attribute attribute, string16* value) {
   std::map<int32, string16>::iterator iter = attributes_.find(attribute);
   if (iter != attributes_.end()) {
     *value = iter->second;
     return true;
   }
 
   return false;
 }
 
-HRESULT BrowserAccessibility::GetAttributeAsBstr(
+HRESULT BrowserAccessibilityWin::GetAttributeAsBstr(
     WebAccessibility::Attribute attribute, BSTR* value_bstr) {
   string16 str;
 
   if (!GetAttribute(attribute, &str))
     return S_FALSE;
 
   if (str.empty())
     return S_FALSE;
 
   *value_bstr = SysAllocString(str.c_str());
   DCHECK(*value_bstr);
 
   return S_OK;
 }
 
-string16 BrowserAccessibility::Escape(string16 str) {
+string16 BrowserAccessibilityWin::Escape(string16 str) {
   return UTF8ToUTF16(EscapeNonASCII(UTF16ToUTF8(str)));
 }
 
-void BrowserAccessibility::InitRoleAndState(LONG web_role,
+void BrowserAccessibilityWin::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;
@@ skipping 278 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_;
 }