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

chrome/browser/ui/views/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/bookmark_bar_view.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 #include <vector>
@@ skipping 908 matching lines @@
 }
 
 void BookmarkBarView::Loaded(BookmarkModel* model) {
   volatile int button_count = GetBookmarkButtonCount();
   DCHECK(button_count == 0);  // If non-zero it means Load was invoked more than
                               // once, or we didn't properly clear things.
                               // Either of which shouldn't happen
   const BookmarkNode* node = model_->GetBookmarkBarNode();
   DCHECK(node && model_->other_node());
   // Create a button for each of the children on the bookmark bar.
-  for (int i = 0, child_count = node->GetChildCount(); i < child_count; ++i)
-    AddChildView(i, CreateBookmarkButton(node->GetChild(i)));
+  for (size_t i = 0, child_count = node->GetChildCount();
+       static_cast<int>(i) < child_count; ++i) {
+    AddChildViewAt(CreateBookmarkButton(node->GetChild(i)), i);
+  }
   UpdateColors();
   other_bookmarked_button_->SetVisible(
       model->other_node()->GetChildCount() > 0);
   other_bookmarked_button_->SetEnabled(true);
 
   Layout();
   SchedulePaint();
 }
 
 void BookmarkBarView::BookmarkModelBeingDeleted(BookmarkModel* model) {
@@ skipping 32 matching lines @@
   NotifyModelChanged();
   if (parent != model_->GetBookmarkBarNode()) {
     // We only care about nodes on the bookmark bar.
     return;
   }
   DCHECK(index >= 0 && index <= GetBookmarkButtonCount());
   const BookmarkNode* node = parent->GetChild(index);
   if (!throbbing_view_ && sync_service_ && sync_service_->SetupInProgress()) {
     StartThrobbing(node, true);
   }
-  AddChildView(index, CreateBookmarkButton(node));
+  AddChildViewAt(CreateBookmarkButton(node), index);
   UpdateColors();
   Layout();
   SchedulePaint();
 }
 
 void BookmarkBarView::BookmarkNodeRemoved(BookmarkModel* model,
                                           const BookmarkNode* parent,
                                           int old_index,
                                           const BookmarkNode* node) {
   BookmarkNodeRemovedImpl(model, parent, old_index);
@@ skipping 55 matching lines @@
     return;  // We only care about reordering of the bookmark bar node.
 
   // Remove the existing buttons.
   while (GetBookmarkButtonCount()) {
     views::View* button = GetChildViewAt(0);
     RemoveChildView(button);
     MessageLoop::current()->DeleteSoon(FROM_HERE, button);
   }
 
   // Create the new buttons.
-  for (int i = 0, child_count = node->GetChildCount(); i < child_count; ++i)
-    AddChildView(i, CreateBookmarkButton(node->GetChild(i)));
+  for (size_t i = 0, child_count = node->GetChildCount();
+       static_cast<int>(i) < child_count; ++i) {
+    AddChildViewAt(CreateBookmarkButton(node->GetChild(i)), i);
+  }
   UpdateColors();
 
   Layout();
   SchedulePaint();
 }
 
 void BookmarkBarView::BookmarkNodeFavIconLoaded(BookmarkModel* model,
                                                 const BookmarkNode* node) {
   BookmarkNodeChangedImpl(model, node);
 }
@@ skipping 72 matching lines @@
 void BookmarkBarView::RunMenu(views::View* view, const gfx::Point& pt) {
   const BookmarkNode* node;
 
   int start_index = 0;
   if (view == other_bookmarked_button_) {
     node = model_->other_node();
   } else if (view == overflow_button_) {
     node = model_->GetBookmarkBarNode();
     start_index = GetFirstHiddenNodeIndex();
   } else {
-    int button_index = GetChildIndex(view);
+    int button_index = GetIndexOf(view);
     DCHECK_NE(-1, button_index);
     node = model_->GetBookmarkBarNode()->GetChild(button_index);
   }
 
   bookmark_menu_ = new BookmarkMenuController(browser_, profile_,
       page_navigator_, GetWindow()->GetNativeWindow(), node, start_index);
   bookmark_menu_->set_observer(this);
   bookmark_menu_->RunMenuAt(this, false);
 }
 
 void BookmarkBarView::ButtonPressed(views::Button* sender,
                                     const views::Event& event) {
   // Show the login wizard if the user clicked the re-login button.
   if (sender->tag() == kSyncErrorButtonTag) {
     DCHECK(sender == sync_error_button_);
     DCHECK(sync_service_ && !sync_service_->IsManaged());
     sync_service_->ShowErrorUI(GetWindow()->GetNativeWindow());
     return;
   }
 
   const BookmarkNode* node;
   if (sender->tag() == kOtherFolderButtonTag) {
     node = model_->other_node();
   } else {
-    int index = GetChildIndex(sender);
+    int index = GetIndexOf(sender);
     DCHECK_NE(-1, index);
     node = model_->GetBookmarkBarNode()->GetChild(index);
   }
   DCHECK(page_navigator_);
 
   WindowOpenDisposition disposition_from_event_flags =
       event_utils::DispositionFromEventFlags(sender->mouse_event_flags());
 
   if (node->is_url()) {
     page_navigator_->OpenURL(node->GetURL(), GURL(),
@@ skipping 17 matching lines @@
   const BookmarkNode* parent = NULL;
   std::vector<const BookmarkNode*> nodes;
   if (source == other_bookmarked_button_) {
     parent = model_->other_node();
     // Do this so the user can open all bookmarks. BookmarkContextMenu makes
     // sure the user can edit/delete the node in this case.
     nodes.push_back(parent);
   } else if (source != this) {
     // User clicked on one of the bookmark buttons, find which one they
     // clicked on.
-    int bookmark_button_index = GetChildIndex(source);
+    int bookmark_button_index = GetIndexOf(source);
     DCHECK(bookmark_button_index != -1 &&
            bookmark_button_index < GetBookmarkButtonCount());
     const BookmarkNode* node =
         model_->GetBookmarkBarNode()->GetChild(bookmark_button_index);
     nodes.push_back(node);
     parent = node->GetParent();
   } else {
     parent = model_->GetBookmarkBarNode();
     nodes.push_back(parent);
   }
@@ skipping 291 matching lines @@
 
   // Use a large number so that the button continues to throb.
   if (throbbing_view_)
     throbbing_view_->StartThrobbing(std::numeric_limits<int>::max());
 }
 
 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 GetChildViewCount() - 5;
+  return child_count() - 5;
 }
 
 void BookmarkBarView::StopThrobbing(bool immediate) {
   if (!throbbing_view_)
     return;
 
   // If not immediate, cycle through 2 more complete cycles.
   throbbing_view_->StartThrobbing(immediate ? 0 : 4);
   throbbing_view_ = NULL;
 }
@@ skipping 44 matching lines @@
     return;
   SkColor text_color =
       theme_provider->GetColor(BrowserThemeProvider::COLOR_BOOKMARK_TEXT);
   for (int i = 0; i < GetBookmarkButtonCount(); ++i)
     GetBookmarkButton(i)->SetEnabledColor(text_color);
   other_bookmarked_button()->SetEnabledColor(text_color);
 }
 
 gfx::Size BookmarkBarView::LayoutItems(bool compute_bounds_only) {
   gfx::Size prefsize;
-  if (!GetParent() && !compute_bounds_only)
+  if (!parent() && !compute_bounds_only)
     return prefsize;
 
   int x = kLeftMargin;
   int top_margin = IsDetached() ? kDetachedTopMargin : 0;
   int y = top_margin;
   int width = View::width() - kRightMargin - kLeftMargin;
   int height = View::height() - top_margin - kBottomMargin;
   int separator_margin = kSeparatorMargin;
 
   if (OnNewTabPage()) {
@@ skipping 135 matching lines @@
   // The tooltip is the only way we have to display text explaining the error
   // to the user.
   sync_error_button->SetTooltipText(
       UTF16ToWide(l10n_util::GetStringUTF16(IDS_SYNC_BOOKMARK_BAR_ERROR_DESC)));
   sync_error_button->SetAccessibleName(
       l10n_util::GetStringUTF16(IDS_ACCNAME_SYNC_ERROR_BUTTON));
   sync_error_button->SetIcon(
       *ResourceBundle::GetSharedInstance().GetBitmapNamed(IDR_WARNING));
   return sync_error_button;
 }