Rework tree APIs to reflect Google style and more const-correctness....

views/accessibility/view_accessibility.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 "views/accessibility/view_accessibility.h"
 
 #include "ui/base/view_prop.h"
 #include "views/controls/button/native_button.h"
 #include "views/widget/widget.h"
 #include "views/widget/widget_win.h"
@@ skipping 90 matching lines @@
 }
 
 STDMETHODIMP ViewAccessibility::accLocation(
     LONG* x_left, LONG* y_top, LONG* width, LONG* height, VARIANT var_id) {
   if (!IsValidId(var_id) || !x_left || !y_top || !width || !height)
     return E_INVALIDARG;
 
   if (!view_)
     return E_FAIL;
 
-  gfx::Rect view_bounds;
-  // Retrieving the parent View to be used for converting from view-to-screen
-  // coordinates.
-  views::View* parent = view_->GetParent();
-
-  if (parent == NULL) {
-    // If no parent, remain within the same View.
-    parent = view_;
-  }
-
-  // Retrieve active View's bounds.
-  view_bounds = view_->bounds();
-
-  if (!view_bounds.IsEmpty()) {
-    *width  = view_bounds.width();
-    *height = view_bounds.height();
-
-    gfx::Point topleft(view_bounds.origin());
-    views::View::ConvertPointToScreen(parent, &topleft);
+  if (!view_->bounds().IsEmpty()) {
+    *width  = view_->width();
+    *height = view_->height();
+    gfx::Point topleft(view_->bounds().origin());
+    views::View::ConvertPointToScreen(view_->parent() ? view_->parent() : view_,
+                                      &topleft);
     *x_left = topleft.x();
     *y_top  = topleft.y();
   } else {
     return E_FAIL;
   }
   return S_OK;
 }
 
 STDMETHODIMP ViewAccessibility::accNavigate(LONG nav_dir, VARIANT start,
                                             VARIANT* end) {
   if (start.vt != VT_I4 || !end)
     return E_INVALIDARG;
 
   if (!view_)
     return E_FAIL;
 
   switch (nav_dir) {
     case NAVDIR_FIRSTCHILD:
     case NAVDIR_LASTCHILD: {
       if (start.lVal != CHILDID_SELF) {
         // Start of navigation must be on the View itself.
         return E_INVALIDARG;
-      } else if (view_->GetChildViewCount() == 0) {
+      } else if (!view_->has_children()) {
         // No children found.
         return S_FALSE;
       }
 
       // Set child_id based on first or last child.
       int child_id = 0;
-      if (nav_dir == NAVDIR_LASTCHILD) {
-        child_id = view_->GetChildViewCount() - 1;
-      }
+      if (nav_dir == NAVDIR_LASTCHILD)
+        child_id = view_->child_count() - 1;
 
       views::View* child = view_->GetChildViewAt(child_id);
       end->vt = VT_DISPATCH;
       end->pdispVal = GetAccessibleForView(child);
       end->pdispVal->AddRef();
       return S_OK;
     }
     case NAVDIR_LEFT:
     case NAVDIR_UP:
     case NAVDIR_PREVIOUS:
     case NAVDIR_RIGHT:
     case NAVDIR_DOWN:
     case NAVDIR_NEXT: {
       // Retrieve parent to access view index and perform bounds checking.
-      views::View* parent = view_->GetParent();
+      views::View* parent = view_->parent();
       if (!parent) {
         return E_FAIL;
       }
 
       if (start.lVal == CHILDID_SELF) {
-        int view_index = parent->GetChildIndex(view_);
+        int view_index = parent->GetIndexOf(view_);
         // Check navigation bounds, adjusting for View child indexing (MSAA
         // child indexing starts with 1, whereas View indexing starts with 0).
         if (!IsValidNav(nav_dir, view_index, -1,
-                        parent->GetChildViewCount() - 1)) {
+                        parent->child_count() - 1)) {
           // Navigation attempted to go out-of-bounds.
           end->vt = VT_EMPTY;
           return S_FALSE;
         } else {
           if (IsNavDirNext(nav_dir)) {
             view_index += 1;
           } else {
             view_index -=1;
           }
         }
 
         views::View* child = parent->GetChildViewAt(view_index);
         end->pdispVal = GetAccessibleForView(child);
         end->vt = VT_DISPATCH;
         end->pdispVal->AddRef();
         return S_OK;
       } else {
         // Check navigation bounds, adjusting for MSAA child indexing (MSAA
         // child indexing starts with 1, whereas View indexing starts with 0).
-        if (!IsValidNav(nav_dir, start.lVal, 0,
-                        parent->GetChildViewCount() + 1)) {
+        if (!IsValidNav(nav_dir, start.lVal, 0, parent->child_count() + 1)) {
             // Navigation attempted to go out-of-bounds.
             end->vt = VT_EMPTY;
             return S_FALSE;
           } else {
             if (IsNavDirNext(nav_dir)) {
               start.lVal += 1;
             } else {
               start.lVal -= 1;
             }
         }
@@ skipping 30 matching lines @@
 
   LONG child_id = V_I4(&var_child);
 
   if (child_id == CHILDID_SELF) {
     // Remain with the same dispatch.
     return S_OK;
   }
 
   views::View* child_view = NULL;
   if (child_id > 0) {
-    if (child_id <= view_->GetChildViewCount()) {
+    int child_id_as_index = child_id - 1;
+    if (child_id_as_index < view_->child_count()) {
       // Note: child_id is a one based index when indexing children.
-      child_view = view_->GetChildViewAt(child_id - 1);
+      child_view = view_->GetChildViewAt(child_id_as_index);
     } else {
       // Attempt to retrieve a child view with the specified id.
       child_view = view_->GetViewByID(child_id);
     }
   } else {
     // Negative values are used for events fired using the view's WidgetWin
     views::WidgetWin* widget =
         static_cast<views::WidgetWin*>(view_->GetWidget());
     child_view = widget->GetAccessibilityViewEventAt(child_id);
   }
 
   if (!child_view) {
     // No child found.
     *disp_child = NULL;
     return E_FAIL;
   }
 
   *disp_child = GetAccessibleForView(child_view);
   (*disp_child)->AddRef();
   return S_OK;
 }
 
 STDMETHODIMP ViewAccessibility::get_accChildCount(LONG* child_count) {
   if (!child_count || !view_)
     return E_INVALIDARG;
 
   if (!view_)
     return E_FAIL;
 
-  *child_count = view_->GetChildViewCount();
+  *child_count = view_->child_count();
   return S_OK;
 }
 
 STDMETHODIMP ViewAccessibility::get_accDefaultAction(
     VARIANT var_id, BSTR* def_action) {
   if (!IsValidId(var_id) || !def_action)
     return E_INVALIDARG;
 
   if (!view_)
     return E_FAIL;
@@ skipping 36 matching lines @@
     return E_FAIL;
 
   views::View* focus = NULL;
   views::FocusManager* focus_manager = view_->GetFocusManager();
   if (focus_manager)
     focus = focus_manager->GetFocusedView();
   if (focus == view_) {
     // This view has focus.
     focus_child->vt = VT_I4;
     focus_child->lVal = CHILDID_SELF;
-  } else if (focus && view_->IsParentOf(focus)) {
+  } else if (focus && view_->Contains(focus)) {
     // Return the child object that has the keyboard focus.
     focus_child->pdispVal = GetAccessibleForView(focus);
     focus_child->pdispVal->AddRef();
     return S_OK;
   } else {
     // Neither this object nor any of its children has the keyboard focus.
     focus_child->vt = VT_EMPTY;
   }
   return S_OK;
 }
@@ skipping 39 matching lines @@
   return S_OK;
 }
 
 STDMETHODIMP ViewAccessibility::get_accParent(IDispatch** disp_parent) {
   if (!disp_parent)
     return E_INVALIDARG;
 
   if (!view_)
     return E_FAIL;
 
-  views::View* parent_view = view_->GetParent();
+  views::View* parent_view = view_->parent();
 
   if (!parent_view) {
     // This function can get called during teardown of WidetWin so we
     // should bail out if we fail to get the HWND.
     if (!view_->GetWidget() || !view_->GetWidget()->GetNativeView()) {
       *disp_parent = NULL;
       return S_FALSE;
     }
 
     // For a View that has no parent (e.g. root), point the accessible parent to
@@ skipping 103 matching lines @@
 void ViewAccessibility::SetState(VARIANT* msaa_state, views::View* view) {
   // Ensure the output param is initialized to zero.
   msaa_state->lVal = 0;
 
   // Default state; all views can have accessibility focus.
   msaa_state->lVal |= STATE_SYSTEM_FOCUSABLE;
 
   if (!view)
     return;
 
-  if (!view->IsEnabled()) {
+  if (!view->IsEnabled())
     msaa_state->lVal |= STATE_SYSTEM_UNAVAILABLE;
-  }
-  if (!view->IsVisible()) {
+  if (!view->IsVisible())
     msaa_state->lVal |= STATE_SYSTEM_INVISIBLE;
-  }
-  if (view->IsHotTracked()) {
+  if (view->IsHotTracked())
     msaa_state->lVal |= STATE_SYSTEM_HOTTRACKED;
-  }
-  if (view->IsPushed()) {
+  if (view->IsPushed())
     msaa_state->lVal |= STATE_SYSTEM_PRESSED;
-  }
-  // Check both for actual View focus, as well as accessibility focus.
-  views::View* parent = view->GetParent();
-
   if (view->HasFocus())
     msaa_state->lVal |= STATE_SYSTEM_FOCUSED;
 
   // Add on any view-specific states.
   msaa_state->lVal |= MSAAState(view->GetAccessibleState());
 }
 
 // IAccessible functions not supported.
 
 STDMETHODIMP ViewAccessibility::get_accSelection(VARIANT* selected) {
@@ skipping 183 matching lines @@
     HWND native_view_window , IAccessible** accessible) {
   if (IsWindow(native_view_window)) {
     LRESULT ret = SendMessage(native_view_window, WM_GETOBJECT, 0,
                               OBJID_CLIENT);
     return ObjectFromLresult(ret, IID_IDispatch, 0,
                              reinterpret_cast<void**>(accessible));
   }
 
   return E_FAIL;
 }