Variety of tweaks to View API.

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 342 matching lines @@
       browser_(browser),
       infobar_visible_(false),
       throbbing_view_(NULL) {
   if (profile->GetProfileSyncService()) {
     // Obtain a pointer to the profile sync service and add our instance as an
     // observer.
     sync_service_ = profile->GetProfileSyncService();
     sync_service_->AddObserver(this);
   }
 
-  SetID(VIEW_ID_BOOKMARK_BAR);
+  set_id(VIEW_ID_BOOKMARK_BAR);
   Init();
   SetProfile(profile);
 
   size_animation_->Reset(IsAlwaysShown() ? 1 : 0);
 }
 
 BookmarkBarView::~BookmarkBarView() {
   NotifyModelChanged();
   if (model_)
     model_->RemoveObserver(this);
@@ skipping 122 matching lines @@
     if (index == GetBookmarkButtonCount()) {
       if (index == 0) {
         x = kLeftMargin;
       } else {
         x = GetBookmarkButton(index - 1)->x() +
             GetBookmarkButton(index - 1)->width();
       }
     } else {
       x = GetBookmarkButton(index)->x();
     }
-    if (GetBookmarkButtonCount() > 0 && GetBookmarkButton(0)->IsVisible()) {
+    if (GetBookmarkButtonCount() > 0 && GetBookmarkButton(0)->visible()) {
       y = GetBookmarkButton(0)->y();
       h = GetBookmarkButton(0)->height();
     }
 
     // Since the drop indicator is painted directly onto the canvas, we must
     // make sure it is painted in the right location if the locale is RTL.
     gfx::Rect indicator_bounds(x - kDropIndicatorWidth / 2,
                                y,
                                kDropIndicatorWidth,
                                h);
@@ skipping 270 matching lines @@
   *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);
-    if (!child->IsVisible())
+    if (!child->visible())
       break;
     if (child->bounds().Contains(adjusted_loc))
       return model_->GetBookmarkBarNode()->GetChild(i);
   }
 
   // Then the overflow button.
-  if (overflow_button_->IsVisible() &&
+  if (overflow_button_->visible() &&
       overflow_button_->bounds().Contains(adjusted_loc)) {
     *start_index = GetFirstHiddenNodeIndex();
     return model_->GetBookmarkBarNode();
   }
 
   // And finally the other folder.
-  if (other_bookmarked_button_->IsVisible() &&
+  if (other_bookmarked_button_->visible() &&
       other_bookmarked_button_->bounds().Contains(adjusted_loc)) {
     return model_->other_node();
   }
 
   return NULL;
 }
 
 views::MenuButton* BookmarkBarView::GetMenuButtonForNode(
     const BookmarkNode* node) {
   if (node == model_->other_node())
@@ skipping 65 matching lines @@
 
   size_animation_.reset(new ui::SlideAnimation(this));
 }
 
 MenuButton* BookmarkBarView::CreateOtherBookmarkedButton() {
   MenuButton* button = new BookmarkFolderButton(
       this,
       UTF16ToWide(l10n_util::GetStringUTF16(IDS_BOOMARK_BAR_OTHER_BOOKMARKED)),
       this,
       false);
-  button->SetID(VIEW_ID_OTHER_BOOKMARKS);
+  button->set_id(VIEW_ID_OTHER_BOOKMARKS);
   button->SetIcon(GetFolderIcon());
   button->SetContextMenuController(this);
   button->set_tag(kOtherFolderButtonTag);
   button->SetAccessibleName(
       l10n_util::GetStringUTF16(IDS_BOOMARK_BAR_OTHER_BOOKMARKED));
   return button;
 }
 
 MenuButton* BookmarkBarView::CreateOverflowButton() {
   MenuButton* button = new OverFlowButton(this);
@@ skipping 132 matching lines @@
   }
   int index = model_->GetBookmarkBarNode()->GetIndexOf(node);
   DCHECK_NE(-1, index);
   views::TextButton* button = GetBookmarkButton(index);
   gfx::Size old_pref = button->GetPreferredSize();
   ConfigureButton(node, button);
   gfx::Size new_pref = button->GetPreferredSize();
   if (old_pref.width() != new_pref.width()) {
     Layout();
     SchedulePaint();
-  } else if (button->IsVisible()) {
+  } else if (button->visible()) {
     button->SchedulePaint();
   }
 }
 
 void BookmarkBarView::BookmarkNodeChildrenReordered(BookmarkModel* model,
                                                     const BookmarkNode* node) {
   NotifyModelChanged();
   if (node != model_->GetBookmarkBarNode())
     return;  // We only care about reordering of the bookmark bar node.
 
@@ skipping 193 matching lines @@
     button->SetIcon(GetFolderIcon());
     ConfigureButton(node, button);
     return button;
   }
 }
 
 void BookmarkBarView::ConfigureButton(const BookmarkNode* node,
                                       views::TextButton* button) {
   button->SetText(UTF16ToWide(node->GetTitle()));
   button->SetAccessibleName(node->GetTitle());
-  button->SetID(VIEW_ID_BOOKMARK_BAR_ELEMENT);
+  button->set_id(VIEW_ID_BOOKMARK_BAR_ELEMENT);
   // We don't always have a theme provider (ui tests, for example).
   if (GetThemeProvider()) {
     button->SetEnabledColor(GetThemeProvider()->GetColor(
         ThemeService::COLOR_BOOKMARK_TEXT));
   }
 
   button->ClearMaxTextSize();
   button->SetContextMenuController(this);
   button->SetDragController(this);
   if (node->is_url()) {
@@ skipping 114 matching lines @@
   // coordinates calculation works, we mirror the event's X coordinate if the
   // locale is RTL.
   int mirrored_x = GetMirroredXInView(event.x());
 
   *index = -1;
   *drop_on = false;
   *is_over_other = *is_over_overflow = false;
 
   bool found = false;
   const int other_delta_x = mirrored_x - other_bookmarked_button_->x();
-  if (other_bookmarked_button_->IsVisible() && other_delta_x >= 0 &&
+  if (other_bookmarked_button_->visible() && other_delta_x >= 0 &&
       other_delta_x < other_bookmarked_button_->width()) {
     // Mouse is over 'other' folder.
     *is_over_other = true;
     *drop_on = true;
     found = true;
   } else if (!GetBookmarkButtonCount()) {
     // No bookmarks, accept the drop.
     *index = 0;
     int ops = data.GetFirstNode(profile_)
         ? ui::DragDropTypes::DRAG_MOVE
         : ui::DragDropTypes::DRAG_COPY | ui::DragDropTypes::DRAG_LINK;
     return bookmark_utils::PreferredDropOperation(event.source_operations(),
                                                   ops);
   }
 
   for (int i = 0; i < GetBookmarkButtonCount() &&
-       GetBookmarkButton(i)->IsVisible() && !found; i++) {
+       GetBookmarkButton(i)->visible() && !found; i++) {
     views::TextButton* button = GetBookmarkButton(i);
     int button_x = mirrored_x - button->x();
     int button_w = button->width();
     if (button_x < button_w) {
       found = true;
       const BookmarkNode* node = model_->GetBookmarkBarNode()->GetChild(i);
       if (node->is_folder()) {
         if (button_x <= views::kDropBetweenPixels) {
           *index = i;
         } else if (button_x < button_w - views::kDropBetweenPixels) {
           *index = i;
           *drop_on = true;
         } else {
           *index = i + 1;
         }
       } else if (button_x < button_w / 2) {
         *index = i;
       } else {
         *index = i + 1;
       }
       break;
     }
   }
 
   if (!found) {
-    if (overflow_button_->IsVisible()) {
+    if (overflow_button_->visible()) {
       // Are we over the overflow button?
       int overflow_delta_x = mirrored_x - overflow_button_->x();
       if (overflow_delta_x >= 0 &&
           overflow_delta_x < overflow_button_->width()) {
         // Mouse is over overflow button.
         *index = GetFirstHiddenNodeIndex();
         *is_over_overflow = true;
       } else if (overflow_delta_x < 0) {
         // Mouse is after the last visible button but before overflow button;
         // use the last visible index.
         *index = GetFirstHiddenNodeIndex();
       } else {
         return ui::DragDropTypes::DRAG_NONE;
       }
-    } else if (!other_bookmarked_button_->IsVisible() ||
+    } else if (!other_bookmarked_button_->visible() ||
                mirrored_x < other_bookmarked_button_->x()) {
       // Mouse is after the last visible button but before more recently
       // bookmarked; use the last visible index.
       *index = GetFirstHiddenNodeIndex();
     } else {
       return ui::DragDropTypes::DRAG_NONE;
     }
   }
 
   if (*drop_on) {
@@ skipping 12 matching lines @@
     return operation;
   }
   return bookmark_utils::BookmarkDropOperation(profile_, event, data,
                                                model_->GetBookmarkBarNode(),
                                                *index);
 }
 
 int BookmarkBarView::GetFirstHiddenNodeIndex() {
   const int bb_count = GetBookmarkButtonCount();
   for (int i = 0; i < bb_count; ++i) {
-    if (!GetBookmarkButton(i)->IsVisible())
+    if (!GetBookmarkButton(i)->visible())
       return i;
   }
   return bb_count;
 }
 
 void BookmarkBarView::StartThrobbing(const BookmarkNode* node,
                                      bool overflow_only) {
   DCHECK(!throbbing_view_);
 
   // Determine which visible button is showing the bookmark (or is an ancestor
@@ skipping 109 matching lines @@
     return;
   SkColor text_color =
       theme_provider->GetColor(ThemeService::COLOR_BOOKMARK_TEXT);
   for (int i = 0; i < GetBookmarkButtonCount(); ++i)
     GetBookmarkButton(i)->SetEnabledColor(text_color);
   other_bookmarked_button()->SetEnabledColor(text_color);
 }
 
 void BookmarkBarView::UpdateOtherBookmarksVisibility() {
   bool has_other_children = model_->other_node()->child_count() > 0;
-  if (has_other_children == other_bookmarked_button_->IsVisible())
+  if (has_other_children == other_bookmarked_button_->visible())
     return;
   other_bookmarked_button_->SetVisible(has_other_children);
   bookmarks_separator_view_->SetVisible(has_other_children);
   Layout();
   SchedulePaint();
 }
 
 gfx::Size BookmarkBarView::LayoutItems(bool compute_bounds_only) {
   gfx::Size prefsize;
   if (!parent() && !compute_bounds_only)
@@ skipping 16 matching lines @@
     separator_margin -= static_cast<int>(kSeparatorMargin * current_state);
   } else {
     // For the attached appearance, pin the content to the bottom of the bar
     // when animating in/out, as shrinking its height instead looks weird.  This
     // also matches how we layout infobars.
     y += View::height() - kBarHeight;
     height += kBarHeight;
   }
 
   gfx::Size other_bookmarked_pref =
-      other_bookmarked_button_->IsVisible() ?
+      other_bookmarked_button_->visible() ?
       other_bookmarked_button_->GetPreferredSize() : gfx::Size();
   gfx::Size overflow_pref = overflow_button_->GetPreferredSize();
   gfx::Size bookmarks_separator_pref =
       bookmarks_separator_view_->GetPreferredSize();
 
   int sync_error_total_width = 0;
   gfx::Size sync_error_button_pref = sync_error_button_->GetPreferredSize();
   if (sync_ui_util::ShouldShowSyncErrorButton(sync_service_)) {
     sync_error_total_width += kButtonPadding + sync_error_button_pref.width();
   }
   int max_x = width - overflow_pref.width() - kButtonPadding -
       bookmarks_separator_pref.width() - sync_error_total_width;
-  if (other_bookmarked_button_->IsVisible())
+  if (other_bookmarked_button_->visible())
     max_x -= other_bookmarked_pref.width() + kButtonPadding;
 
   // Next, layout out the buttons. Any buttons that are placed beyond the
   // visible region and made invisible.
   if (GetBookmarkButtonCount() == 0 && model_ && model_->IsLoaded()) {
     gfx::Size pref = instructions_->GetPreferredSize();
     if (!compute_bounds_only) {
       instructions_->SetBounds(
           x + kInstructionsPadding, y,
           std::min(static_cast<int>(pref.width()),
@@ skipping 13 matching lines @@
         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());
+       GetChildViewAt(GetBookmarkButtonCount() - 1)->visible());
 
   // 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);
     overflow_button_->SetVisible(!all_visible);
   }
   x += overflow_pref.width();
 
   // Separator.
-  if (bookmarks_separator_view_->IsVisible()) {
+  if (bookmarks_separator_view_->visible()) {
     if (!compute_bounds_only) {
       bookmarks_separator_view_->SetBounds(x,
                                            y - top_margin,
                                            bookmarks_separator_pref.width(),
                                            height + top_margin + kBottomMargin -
                                            separator_margin);
     }
 
     x += bookmarks_separator_pref.width();
   }
 
   // The other bookmarks button.
-  if (other_bookmarked_button_->IsVisible()) {
+  if (other_bookmarked_button_->visible()) {
     if (!compute_bounds_only) {
       other_bookmarked_button_->SetBounds(x, y, other_bookmarked_pref.width(),
                                           height);
     }
     x += other_bookmarked_pref.width() + kButtonPadding;
   }
 
   // Set the real bounds of the sync error button only if it needs to appear on
   // the bookmarks bar.
   if (sync_ui_util::ShouldShowSyncErrorButton(sync_service_)) {
@@ skipping 36 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;
 }