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

views/controls/menu/menu_controller.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/controls/menu/menu_controller.h"
 
 #include "base/i18n/rtl.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "ui/base/dragdrop/os_exchange_data.h"
@@ skipping 63 matching lines @@
 }
 
 // Returns the first descendant of |view| that is hot tracked.
 static View* GetFirstHotTrackedView(View* view) {
   if (!view)
     return NULL;
 
   if (view->IsHotTracked())
     return view;
 
-  for (int i = 0; i < view->GetChildViewCount(); ++i) {
+  for (int i = 0; i < view->child_count(); ++i) {
     View* hot_view = GetFirstHotTrackedView(view->GetChildViewAt(i));
     if (hot_view)
       return hot_view;
   }
   return NULL;
 }
 
 // Recurses through the child views of |view| returning the first view starting
 // at |start| that is focusable. A value of -1 for |start| indicates to start at
 // the first view (if |forward| is false, iterating starts at the last view). If
 // |forward| is true the children are considered first to last, otherwise last
 // to first.
 static View* GetFirstFocusableView(View* view, int start, bool forward) {
   if (forward) {
-    for (int i = start == -1 ? 0 : start; i < view->GetChildViewCount(); ++i) {
+    for (int i = start == -1 ? 0 : start; i < view->child_count(); ++i) {
       View* deepest = GetFirstFocusableView(view->GetChildViewAt(i), -1,
                                             forward);
       if (deepest)
         return deepest;
     }
   } else {
-    for (int i = start == -1 ? view->GetChildViewCount() - 1 : start;
-         i >= 0; --i) {
+    for (int i = start == -1 ? view->child_count() - 1 : start; i >= 0; --i) {
       View* deepest = GetFirstFocusableView(view->GetChildViewAt(i), -1,
                                             forward);
       if (deepest)
         return deepest;
     }
   }
   return view->IsFocusableInRootView() ? view : NULL;
 }
 
 // Returns the first child of |start| that is focusable.
 static View* GetInitialFocusableView(View* start, bool forward) {
   return GetFirstFocusableView(start, -1, forward);
 }
 
 // Returns the next view after |start_at| that is focusable. Returns NULL if
 // there are no focusable children of |ancestor| after |start_at|.
 static View* GetNextFocusableView(View* ancestor,
                                   View* start_at,
                                   bool forward) {
-  DCHECK(ancestor->IsParentOf(start_at));
+  DCHECK(ancestor->Contains(start_at));
   View* parent = start_at;
   do {
-    View* new_parent = parent->GetParent();
-    int index = new_parent->GetChildIndex(parent);
+    View* new_parent = parent->parent();
+    int index = new_parent->GetIndexOf(parent);
     index += forward ? 1 : -1;
     if (forward || index != -1) {
       View* next = GetFirstFocusableView(new_parent, index, forward);
       if (next)
         return next;
     }
     parent = new_parent;
   } while (parent != ancestor);
   return NULL;
 }
@@ skipping 949 matching lines @@
     i->submenu_open = false;
     i->item = last_item;
   }
 }
 
 MenuItemView* MenuController::GetMenuItemAt(View* source, int x, int y) {
   // Walk the view hierarchy until we find a menu item (or the root).
   View* child_under_mouse = source->GetViewForPoint(gfx::Point(x, y));
   while (child_under_mouse &&
          child_under_mouse->GetID() != MenuItemView::kMenuItemViewID) {
-    child_under_mouse = child_under_mouse->GetParent();
+    child_under_mouse = child_under_mouse->parent();
   }
   if (child_under_mouse && child_under_mouse->IsEnabled() &&
       child_under_mouse->GetID() == MenuItemView::kMenuItemViewID) {
     return static_cast<MenuItemView*>(child_under_mouse);
   }
   return NULL;
 }
 
 MenuItemView* MenuController::GetEmptyMenuItemAt(View* source, int x, int y) {
   View* child_under_mouse = source->GetViewForPoint(gfx::Point(x, y));
@@ skipping 374 matching lines @@
       item->GetSubmenu()->IsShowing()) {
     // A menu is selected and open, but none of its children are selected,
     // select the first menu item.
     if (item->GetSubmenu()->GetMenuItemCount()) {
       SetSelection(item->GetSubmenu()->GetMenuItemAt(0), SELECTION_DEFAULT);
       ScrollToVisible(item->GetSubmenu()->GetMenuItemAt(0));
       return;
     }
   }
 
-  if (item->GetChildViewCount()) {
+  if (item->has_children()) {
     View* hot_view = GetFirstHotTrackedView(item);
     if (hot_view) {
       hot_view->SetHotTracked(false);
       View* to_make_hot = GetNextFocusableView(item, hot_view, delta == 1);
       if (to_make_hot) {
         to_make_hot->SetHotTracked(true);
         return;
       }
     } else {
       View* to_make_hot = GetInitialFocusableView(item, delta == 1);
@@ skipping 252 matching lines @@
 
 void MenuController::StopScrolling() {
   scroll_task_.reset(NULL);
 }
 
 void MenuController::UpdateActiveMouseView(SubmenuView* event_source,
                                            const MouseEvent& event,
                                            View* target_menu) {
   View* target = NULL;
   gfx::Point target_menu_loc(event.location());
-  if (target_menu && target_menu->GetChildViewCount()) {
+  if (target_menu && target_menu->has_children()) {
     // Locate the deepest child view to send events to.  This code assumes we
     // don't have to walk up the tree to find a view interested in events. This
     // is currently true for the cases we are embedding views, but if we embed
     // more complex hierarchies it'll need to change.
     View::ConvertPointToScreen(event_source->GetScrollViewContainer(),
                                &target_menu_loc);
     View::ConvertPointToView(NULL, target_menu, &target_menu_loc);
     target = target_menu->GetViewForPoint(target_menu_loc);
     if (target == target_menu || !target->IsEnabled())
       target = NULL;
@@ skipping 56 matching lines @@
 
   MouseEvent release_event(Event::ET_MOUSE_RELEASED, -1, -1, 0);
   // Reset the active_mouse_view_ before sending mouse released. That way if if
   // calls back to use we aren't in a weird state.
   View* active_view = active_mouse_view_;
   active_mouse_view_ = NULL;
   active_view->OnMouseReleased(release_event, true);
 }
 
 }  // namespace views