Convert some more view methods to the ui/views style.

chrome/browser/ui/views/bookmarks/bookmark_bar_view.cc

 // Copyright (c) 2011 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/ui/views/bookmarks/bookmark_bar_view.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 #include <vector>
@@ skipping 416 matching lines @@
   // Disable the other bookmarked button, we'll re-enable when the model is
   // loaded.
   other_bookmarked_button_->SetEnabled(false);
 
   Source<Profile> ns_source(profile_->GetOriginalProfile());
   registrar_.Add(this, chrome::NOTIFICATION_BOOKMARK_BUBBLE_SHOWN, ns_source);
   registrar_.Add(this, chrome::NOTIFICATION_BOOKMARK_BUBBLE_HIDDEN, ns_source);
 
   // Remove any existing bookmark buttons.
   while (GetBookmarkButtonCount())
-    delete GetChildViewAt(0);
+    delete child_at(0);
 
   model_ = profile_->GetBookmarkModel();
   if (model_) {
     model_->AddObserver(this);
     if (model_->IsLoaded())
       Loaded(model_);
     // else case: we'll receive notification back from the BookmarkModel when
     // done loading, then we'll populate the bar.
   }
 }
@@ skipping 41 matching lines @@
     int* model_start_index) {
   *model_start_index = 0;
 
   if (loc.x() < 0 || loc.x() >= width() || loc.y() < 0 || loc.y() >= height())
     return NULL;
 
   gfx::Point adjusted_loc(GetMirroredXInView(loc.x()), loc.y());
 
   // Check the buttons first.
   for (int i = 0; i < GetBookmarkButtonCount(); ++i) {
-    views::View* child = GetChildViewAt(i);
+    views::View* child = child_at(i);
     if (!child->IsVisible())
       break;
     if (child->bounds().Contains(adjusted_loc))
       return model_->GetBookmarkBarNode()->GetChild(i);
   }
 
   // Then the overflow button.
   if (overflow_button_->IsVisible() &&
       overflow_button_->bounds().Contains(adjusted_loc)) {
     *model_start_index = GetFirstHiddenNodeIndex();
@@ skipping 11 matching lines @@
 
 views::MenuButton* BookmarkBarView::GetMenuButtonForNode(
     const BookmarkNode* node) {
   if (node == model_->other_node())
     return other_bookmarked_button_;
   if (node == model_->GetBookmarkBarNode())
     return overflow_button_;
   int index = model_->GetBookmarkBarNode()->GetIndexOf(node);
   if (index == -1 || !node->is_folder())
     return NULL;
-  return static_cast<views::MenuButton*>(GetChildViewAt(index));
+  return static_cast<views::MenuButton*>(child_at(index));
 }
 
 void BookmarkBarView::GetAnchorPositionForButton(
     views::MenuButton* button,
     MenuItemView::AnchorPosition* anchor) {
   if (button == other_bookmarked_button_ || button == overflow_button_)
     *anchor = MenuItemView::TOPRIGHT;
   else
     *anchor = MenuItemView::TOPLEFT;
 }
@@ skipping 417 matching lines @@
   BookmarkNodeChangedImpl(model, node);
 }
 
 void BookmarkBarView::BookmarkNodeChildrenReordered(BookmarkModel* model,
                                                     const BookmarkNode* node) {
   if (node != model_->GetBookmarkBarNode())
     return;  // We only care about reordering of the bookmark bar node.
 
   // Remove the existing buttons.
   while (GetBookmarkButtonCount()) {
-    views::View* button = GetChildViewAt(0);
+    views::View* button = child_at(0);
     RemoveChildView(button);
     MessageLoop::current()->DeleteSoon(FROM_HERE, button);
   }
 
   // Create the new buttons.
   for (int i = 0, child_count = node->child_count(); i < child_count; ++i)
     AddChildViewAt(CreateBookmarkButton(node->GetChild(i)), i);
   UpdateColors();
 
   Layout();
@@ skipping 225 matching lines @@
 
 int BookmarkBarView::GetBookmarkButtonCount() {
   // We contain five non-bookmark button views: other bookmarks, bookmarks
   // separator, chevrons (for overflow), the instruction label and the sync
   // error button.
   return child_count() - 5;
 }
 
 views::TextButton* BookmarkBarView::GetBookmarkButton(int index) {
   DCHECK(index >= 0 && index < GetBookmarkButtonCount());
-  return static_cast<views::TextButton*>(GetChildViewAt(index));
+  return static_cast<views::TextButton*>(child_at(index));
 }
 
 int BookmarkBarView::GetFirstHiddenNodeIndex() {
   const int bb_count = GetBookmarkButtonCount();
   for (int i = 0; i < bb_count; ++i) {
     if (!GetBookmarkButton(i)->IsVisible())
       return i;
   }
   return bb_count;
 }
@@ skipping 116 matching lines @@
 
   StopThrobbing(true);
   // No need to start throbbing again as the bookmark bubble can't be up at
   // the same time as the user reorders.
 
   if (parent != model_->GetBookmarkBarNode()) {
     // We only care about nodes on the bookmark bar.
     return;
   }
   DCHECK(index >= 0 && index < GetBookmarkButtonCount());
-  views::View* button = GetChildViewAt(index);
+  views::View* button = child_at(index);
   RemoveChildView(button);
   MessageLoop::current()->DeleteSoon(FROM_HERE, button);
   Layout();
   SchedulePaint();
 }
 
 void BookmarkBarView::BookmarkNodeChangedImpl(BookmarkModel* model,
                                               const BookmarkNode* node) {
   if (node->parent() != model_->GetBookmarkBarNode()) {
     // We only care about nodes on the bookmark bar.
@@ skipping 184 matching lines @@
     if (parent == bbn)
       break;
     parent_on_bb = parent;
   }
   if (parent_on_bb) {
     int index = bbn->GetIndexOf(parent_on_bb);
     if (index >= GetFirstHiddenNodeIndex()) {
       // Node is hidden, animate the overflow button.
       throbbing_view_ = overflow_button_;
     } else if (!overflow_only) {
-      throbbing_view_ = static_cast<CustomButton*>(GetChildViewAt(index));
+      throbbing_view_ = static_cast<CustomButton*>(child_at(index));
     }
   } else if (!overflow_only) {
     throbbing_view_ = other_bookmarked_button_;
   }
 
   // Use a large number so that the button continues to throb.
   if (throbbing_view_)
     throbbing_view_->StartThrobbing(std::numeric_limits<int>::max());
 }
 
 views::CustomButton* BookmarkBarView::DetermineViewToThrobFromRemove(
     const BookmarkNode* parent,
     int old_index) {
   const BookmarkNode* bbn = model_->GetBookmarkBarNode();
   const BookmarkNode* old_node = parent;
   int old_index_on_bb = old_index;
   while (old_node && old_node != bbn) {
     const BookmarkNode* parent = old_node->parent();
     if (parent == bbn) {
       old_index_on_bb = bbn->GetIndexOf(old_node);
       break;
     }
     old_node = parent;
   }
   if (old_node) {
     if (old_index_on_bb >= GetFirstHiddenNodeIndex()) {
       // Node is hidden, animate the overflow button.
       return overflow_button_;
     }
-    return static_cast<CustomButton*>(GetChildViewAt(old_index_on_bb));
+    return static_cast<CustomButton*>(child_at(old_index_on_bb));
   }
   // Node wasn't on the bookmark bar, use the other bookmark button.
   return other_bookmarked_button_;
 }
 
 void BookmarkBarView::UpdateColors() {
   // We don't always have a theme provider (ui tests, for example).
   const ui::ThemeProvider* theme_provider = GetThemeProvider();
   if (!theme_provider)
     return;
@@ skipping 69 matching lines @@
           std::min(static_cast<int>(pref.width()),
           max_x - x),
           height);
       instructions_->SetVisible(true);
     }
   } else {
     if (!compute_bounds_only)
       instructions_->SetVisible(false);
 
     for (int i = 0; i < GetBookmarkButtonCount(); ++i) {
-      views::View* child = GetChildViewAt(i);
+      views::View* child = child_at(i);
       gfx::Size pref = child->GetPreferredSize();
       int next_x = x + pref.width() + kButtonPadding;
       if (!compute_bounds_only) {
         child->SetVisible(next_x < max_x);
         child->SetBounds(x, y, pref.width(), height);
       }
       x = next_x;
     }
   }
 
   // Layout the right side of the bar.
   const bool all_visible =
       (GetBookmarkButtonCount() == 0 ||
-       GetChildViewAt(GetBookmarkButtonCount() - 1)->IsVisible());
+       child_at(GetBookmarkButtonCount() - 1)->IsVisible());
 
   // Layout the right side buttons.
   if (!compute_bounds_only)
     x = max_x + kButtonPadding;
   else
     x += kButtonPadding;
 
   // The overflow button.
   if (!compute_bounds_only) {
     overflow_button_->SetBounds(x, y, overflow_pref.width(), height);
@@ skipping 53 matching lines @@
               (1 - size_animation_->GetCurrentValue())));
     } else {
       prefsize.set_height(
           static_cast<int>(
               browser_defaults::kBookmarkBarHeight *
               size_animation_->GetCurrentValue()));
     }
   }
   return prefsize;
 }