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

views/focus/focus_search.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 "base/logging.h"
 #include "views/focus/focus_manager.h"
 #include "views/focus/focus_search.h"
 #include "views/view.h"
 
 namespace views {
 
 FocusSearch::FocusSearch(View* root, bool cycle, bool accessibility_mode)
     : root_(root),
       cycle_(cycle),
       accessibility_mode_(accessibility_mode) {
 }
 
 View* FocusSearch::FindNextFocusableView(View* starting_view,
                                          bool reverse,
                                          Direction direction,
                                          bool check_starting_view,
                                          FocusTraversable** focus_traversable,
                                          View** focus_traversable_view) {
   *focus_traversable = NULL;
   *focus_traversable_view = NULL;
 
-  if (root_->GetChildViewCount() == 0) {
+  if (!root_->has_children()) {
     NOTREACHED();
     // Nothing to focus on here.
     return NULL;
   }
 
   View* initial_starting_view = starting_view;
   int starting_view_group = -1;
   if (starting_view)
     starting_view_group = starting_view->GetGroup();
 
   if (!starting_view) {
     // Default to the first/last child
     starting_view =
         reverse ?
-        root_->GetChildViewAt(root_->GetChildViewCount() - 1) :
+        root_->GetChildViewAt(root_->child_count() - 1) :
         root_->GetChildViewAt(0);
     // If there was no starting view, then the one we select is a potential
     // focus candidate.
     check_starting_view = true;
   } else {
     // The starting view should be a direct or indirect child of the root.
-    DCHECK(root_->IsParentOf(starting_view));
+    DCHECK(root_->Contains(starting_view));
   }
 
   View* v = NULL;
   if (!reverse) {
     v = FindNextFocusableViewImpl(starting_view, check_starting_view,
                                   true,
                                   (direction == DOWN) ? true : false,
                                   starting_view_group,
                                   focus_traversable,
                                   focus_traversable_view);
   } else {
     // If the starting view is focusable, we don't want to go down, as we are
     // traversing the view hierarchy tree bottom-up.
     bool can_go_down = (direction == DOWN) && !IsFocusable(starting_view);
     v = FindPreviousFocusableViewImpl(starting_view, check_starting_view,
                                       true,
                                       can_go_down,
                                       starting_view_group,
                                       focus_traversable,
                                       focus_traversable_view);
   }
 
   // Don't set the focus to something outside of this view hierarchy.
-  if (v && v != root_ && !root_->IsParentOf(v))
+  if (v && v != root_ && !root_->Contains(v))
     v = NULL;
 
   // If |cycle_| is true, prefer to keep cycling rather than returning NULL.
   if (cycle_ && !v && initial_starting_view) {
     v = FindNextFocusableView(NULL, reverse, direction, check_starting_view,
                               focus_traversable, focus_traversable_view);
     DCHECK(IsFocusable(v));
     return v;
   }
 
@@ skipping 30 matching lines @@
 
   View* selected_view = view->GetSelectedViewForGroup(view->GetGroup());
   if (selected_view)
     return selected_view;
 
   // No view selected for that group, default to the specified view.
   return view;
 }
 
 View* FocusSearch::GetParent(View* v) {
-  if (root_->IsParentOf(v)) {
-    return v->GetParent();
-  } else {
-    return NULL;
-  }
+  return root_->Contains(v) ? v->parent() : NULL;
 }
 
 // Strategy for finding the next focusable view:
 // - keep going down the first child, stop when you find a focusable view or
 //   a focus traversable view (in that case return it) or when you reach a view
 //   with no children.
 // - go to the right sibling and start the search from there (by invoking
 //   FindNextFocusableViewImpl on that view).
 // - if the view has no right sibling, go up the parents until you find a parent
 //   with a right sibling and start the search from there.
@@ skipping 16 matching lines @@
 
     *focus_traversable = starting_view->GetFocusTraversable();
     if (*focus_traversable) {
       *focus_traversable_view = starting_view;
       return NULL;
     }
   }
 
   // First let's try the left child.
   if (can_go_down) {
-    if (starting_view->GetChildViewCount() > 0) {
+    if (starting_view->has_children()) {
       View* v = FindNextFocusableViewImpl(starting_view->GetChildViewAt(0),
                                           true, false, true, skip_group_id,
                                           focus_traversable,
                                           focus_traversable_view);
       if (v || *focus_traversable)
         return v;
     }
   }
 
   // Then try the right sibling.
@@ skipping 44 matching lines @@
   // Let's go down and right as much as we can.
   if (can_go_down) {
     // Before we go into the direct children, we have to check if this view has
     // a FocusTraversable.
     *focus_traversable = starting_view->GetFocusTraversable();
     if (*focus_traversable) {
       *focus_traversable_view = starting_view;
       return NULL;
     }
 
-    if (starting_view->GetChildViewCount() > 0) {
+    if (starting_view->has_children()) {
       View* view =
-          starting_view->GetChildViewAt(starting_view->GetChildViewCount() - 1);
+          starting_view->GetChildViewAt(starting_view->child_count() - 1);
       View* v = FindPreviousFocusableViewImpl(view, true, false, true,
                                               skip_group_id,
                                               focus_traversable,
                                               focus_traversable_view);
       if (v || *focus_traversable)
         return v;
     }
   }
 
   // Then look at this view. Here, we do not need to see if the view has
@@ skipping 26 matching lines @@
                                            skip_group_id,
                                            focus_traversable,
                                            focus_traversable_view);
   }
 
   // We found nothing.
   return NULL;
 }
 
 }  // namespace views