bookmarks: Cleanup - Rename 'OtherBookmarked' to 'OtherBookmarks'.

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

 // Copyright (c) 2012 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 <string>
 #include <vector>
@@ skipping 325 matching lines @@
     owner_->StopThrobbing(true);
     return views::MenuButton::OnMousePressed(e);
   }
 
  private:
   BookmarkBarView* owner_;
 
   DISALLOW_COPY_AND_ASSIGN(OverFlowButton);
 };
 
-void RecordAppLaunch(Profile* profile, GURL url) {
+void RecordAppLaunch(Profile* profile, const GURL& url) {
   const extensions::Extension* extension =
       extensions::ExtensionRegistry::Get(profile)
           ->enabled_extensions().GetAppByURL(url);
   if (!extension)
     return;
 
   extensions::RecordAppLaunchType(extension_misc::APP_LAUNCH_BOOKMARK_BAR,
                                   extension->GetType());
 }
 
@@ skipping 88 matching lines @@
 // BookmarkBarView ------------------------------------------------------------
 
 // static
 const char BookmarkBarView::kViewClassName[] = "BookmarkBarView";
 
 BookmarkBarView::BookmarkBarView(Browser* browser, BrowserView* browser_view)
     : page_navigator_(NULL),
       client_(NULL),
       bookmark_menu_(NULL),
       bookmark_drop_menu_(NULL),
-      other_bookmarked_button_(NULL),
+      other_bookmarks_button_(NULL),
       managed_bookmarks_button_(NULL),
       apps_page_shortcut_(NULL),
       overflow_button_(NULL),
       instructions_(NULL),
       bookmarks_separator_view_(NULL),
       browser_(browser),
       browser_view_(browser_view),
       infobar_visible_(false),
       throbbing_view_(NULL),
       bookmark_bar_state_(BookmarkBar::SHOW),
@@ skipping 99 matching lines @@
   }
 
   // Then the overflow button.
   if (overflow_button_->visible() &&
       overflow_button_->bounds().Contains(adjusted_loc)) {
     *model_start_index = GetFirstHiddenNodeIndex();
     return model_->bookmark_bar_node();
   }
 
   // And finally the other folder.
-  if (other_bookmarked_button_->visible() &&
-      other_bookmarked_button_->bounds().Contains(adjusted_loc)) {
+  if (other_bookmarks_button_->visible() &&
+      other_bookmarks_button_->bounds().Contains(adjusted_loc)) {
     return model_->other_node();
   }
 
   return NULL;
 }
 
 views::MenuButton* BookmarkBarView::GetMenuButtonForNode(
     const BookmarkNode* node) {
   if (node == client_->managed_node())
     return managed_bookmarks_button_;
   if (node == model_->other_node())
-    return other_bookmarked_button_;
+    return other_bookmarks_button_;
   if (node == model_->bookmark_bar_node())
     return overflow_button_;
   int index = model_->bookmark_bar_node()->GetIndexOf(node);
   if (index == -1 || !node->is_folder())
     return NULL;
   return static_cast<views::MenuButton*>(child_at(index));
 }
 
 void BookmarkBarView::GetAnchorPositionForButton(
     views::MenuButton* button,
     views::MenuAnchorPosition* anchor) {
-  if (button == other_bookmarked_button_ || button == overflow_button_)
+  if (button == other_bookmarks_button_ || button == overflow_button_)
     *anchor = views::MENU_ANCHOR_TOPRIGHT;
   else
     *anchor = views::MENU_ANCHOR_TOPLEFT;
 }
 
 views::MenuItemView* BookmarkBarView::GetMenu() {
   return bookmark_menu_ ? bookmark_menu_->menu() : NULL;
 }
 
 views::MenuItemView* BookmarkBarView::GetContextMenu() {
@@ skipping 125 matching lines @@
     width += 2 * static_cast<int>(kNewTabHorizontalPadding * current_state);
     height += static_cast<int>(
         (chrome::kNTPBookmarkBarHeight - chrome::kBookmarkBarHeight) *
             current_state);
   }
 
   if (managed_bookmarks_button_->visible()) {
     gfx::Size size = managed_bookmarks_button_->GetPreferredSize();
     width += size.width() + kButtonPadding;
   }
-  if (other_bookmarked_button_->visible()) {
-    gfx::Size size = other_bookmarked_button_->GetPreferredSize();
+  if (other_bookmarks_button_->visible()) {
+    gfx::Size size = other_bookmarks_button_->GetPreferredSize();
     width += size.width() + kButtonPadding;
   }
   if (overflow_button_->visible()) {
     gfx::Size size = overflow_button_->GetPreferredSize();
     width += size.width() + kButtonPadding;
   }
   if (bookmarks_separator_view_->visible()) {
     gfx::Size size = bookmarks_separator_view_->GetPreferredSize();
     width += size.width();
   }
@@ skipping 23 matching lines @@
     y += (View::height() - chrome::kBookmarkBarHeight) / 2;
     width -= static_cast<int>(kNewTabHorizontalPadding * current_state);
     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() - chrome::kBookmarkBarHeight;
   }
 
-  gfx::Size other_bookmarked_pref = other_bookmarked_button_->visible() ?
-      other_bookmarked_button_->GetPreferredSize() : gfx::Size();
+  gfx::Size other_bookmarks_pref = other_bookmarks_button_->visible() ?
+      other_bookmarks_button_->GetPreferredSize() : gfx::Size();
   gfx::Size overflow_pref = overflow_button_->GetPreferredSize();
   gfx::Size bookmarks_separator_pref =
       bookmarks_separator_view_->GetPreferredSize();
   gfx::Size apps_page_shortcut_pref = apps_page_shortcut_->visible() ?
       apps_page_shortcut_->GetPreferredSize() : gfx::Size();
 
   int max_x = width - overflow_pref.width() - kButtonPadding -
       bookmarks_separator_pref.width();
-  if (other_bookmarked_button_->visible())
-    max_x -= other_bookmarked_pref.width() + kButtonPadding;
+  if (other_bookmarks_button_->visible())
+    max_x -= other_bookmarks_pref.width() + kButtonPadding;
 
   // Start with the apps page shortcut button.
   if (apps_page_shortcut_->visible()) {
     apps_page_shortcut_->SetBounds(x, y, apps_page_shortcut_pref.width(),
                                    height);
     x += apps_page_shortcut_pref.width() + kButtonPadding;
   }
 
   // Then comes the managed bookmarks folder, if visible.
   if (managed_bookmarks_button_->visible()) {
@@ skipping 58 matching lines @@
   if (bookmarks_separator_view_->visible()) {
     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_->visible()) {
-    other_bookmarked_button_->SetBounds(x, y, other_bookmarked_pref.width(),
-                                        height);
-    x += other_bookmarked_pref.width() + kButtonPadding;
+  // The "Other Bookmarks" button.
+  if (other_bookmarks_button_->visible()) {
+    other_bookmarks_button_->SetBounds(x, y, other_bookmarks_pref.width(),
+                                       height);
+    x += other_bookmarks_pref.width() + kButtonPadding;
   }
 }
 
 void BookmarkBarView::ViewHierarchyChanged(
     const ViewHierarchyChangedDetails& details) {
   if (details.is_add && details.child == this) {
     // We may get inserted into a hierarchy with a profile - this typically
     // occurs when the bar's contents get populated fast enough that the
     // buttons are created before the bar is attached to a frame.
     UpdateColors();
@@ skipping 252 matching lines @@
   StopThrobbing(false);
 }
 
 void BookmarkBarView::BookmarkModelLoaded(BookmarkModel* model,
                                           bool ids_reassigned) {
   // There should be no buttons. If non-zero it means Load was invoked more than
   // once, or we didn't properly clear things. Either of which shouldn't happen.
   // The actual bookmark buttons are added from Layout().
   DCHECK_EQ(0, GetBookmarkButtonCount());
   DCHECK(model->other_node());
-  other_bookmarked_button_->SetAccessibleName(model->other_node()->GetTitle());
-  other_bookmarked_button_->SetText(model->other_node()->GetTitle());
+  other_bookmarks_button_->SetAccessibleName(model->other_node()->GetTitle());
+  other_bookmarks_button_->SetText(model->other_node()->GetTitle());
   managed_bookmarks_button_->SetAccessibleName(
       client_->managed_node()->GetTitle());
   managed_bookmarks_button_->SetText(client_->managed_node()->GetTitle());
   UpdateColors();
   UpdateOtherAndManagedButtonsVisibility();
-  other_bookmarked_button_->SetEnabled(true);
+  other_bookmarks_button_->SetEnabled(true);
   managed_bookmarks_button_->SetEnabled(true);
   LayoutAndPaint();
 }
 
 void BookmarkBarView::BookmarkModelBeingDeleted(BookmarkModel* model) {
   NOTREACHED();
   // Do minimal cleanup, presumably we'll be deleted shortly.
   model_->RemoveObserver(this);
   model_ = NULL;
 }
@@ skipping 151 matching lines @@
     }
   }
   return true;
 }
 
 void BookmarkBarView::OnMenuButtonClicked(views::View* view,
                                           const gfx::Point& point) {
   const BookmarkNode* node;
 
   int start_index = 0;
-  if (view == other_bookmarked_button_) {
+  if (view == other_bookmarks_button_) {
     node = model_->other_node();
   } else if (view == managed_bookmarks_button_) {
     node = client_->managed_node();
   } else if (view == overflow_button_) {
     node = model_->bookmark_bar_node();
     start_index = GetFirstHiddenNodeIndex();
   } else {
     int button_index = GetIndexOf(view);
     DCHECK_NE(-1, button_index);
     node = model_->bookmark_bar_node()->GetChild(button_index);
@@ skipping 51 matching lines @@
 void BookmarkBarView::ShowContextMenuForView(views::View* source,
                                              const gfx::Point& point,
                                              ui::MenuSourceType source_type) {
   if (!model_->loaded()) {
     // Don't do anything if the model isn't loaded.
     return;
   }
 
   const BookmarkNode* parent = NULL;
   std::vector<const BookmarkNode*> nodes;
-  if (source == other_bookmarked_button_) {
+  if (source == other_bookmarks_button_) {
     parent = model_->other_node();
     // Do this so the user can open all bookmarks. BookmarkContextMenu makes
     // sure the user can't edit/delete the node in this case.
     nodes.push_back(parent);
   } else if (source == managed_bookmarks_button_) {
     parent = client_->managed_node();
     nodes.push_back(parent);
   } else if (source != this && source != apps_page_shortcut_) {
     // User clicked on one of the bookmark buttons, find which one they
     // clicked on, except for the apps page shortcut, which must behave as if
@@ skipping 23 matching lines @@
   // Note that at this point we're not in a hierarchy so GetThemeProvider() will
   // return NULL.  When we're inserted into a hierarchy, we'll call
   // UpdateColors(), which will set the appropriate colors for all the objects
   // added in this function.
 
   // Child views are traversed in the order they are added. Make sure the order
   // they are added matches the visual order.
   overflow_button_ = CreateOverflowButton();
   AddChildView(overflow_button_);
 
-  other_bookmarked_button_ = CreateOtherBookmarkedButton();
+  other_bookmarks_button_ = CreateOtherBookmarksButton();
   // We'll re-enable when the model is loaded.
-  other_bookmarked_button_->SetEnabled(false);
-  AddChildView(other_bookmarked_button_);
+  other_bookmarks_button_->SetEnabled(false);
+  AddChildView(other_bookmarks_button_);
 
   managed_bookmarks_button_ = CreateManagedBookmarksButton();
   // Also re-enabled when the model is loaded.
   managed_bookmarks_button_->SetEnabled(false);
   AddChildView(managed_bookmarks_button_);
 
   apps_page_shortcut_ = CreateAppsPageShortcutButton();
   AddChildView(apps_page_shortcut_);
   profile_pref_registrar_.Init(browser_->profile()->GetPrefs());
   profile_pref_registrar_.Add(
@@ skipping 50 matching lines @@
 
 int BookmarkBarView::GetFirstHiddenNodeIndex() {
   const int bb_count = GetBookmarkButtonCount();
   for (int i = 0; i < bb_count; ++i) {
     if (!GetBookmarkButton(i)->visible())
       return i;
   }
   return bb_count;
 }
 
-MenuButton* BookmarkBarView::CreateOtherBookmarkedButton() {
+MenuButton* BookmarkBarView::CreateOtherBookmarksButton() {
   // Title is set in Loaded.
   MenuButton* button =
       new BookmarkFolderButton(this, base::string16(), this, false);
   button->set_id(VIEW_ID_OTHER_BOOKMARKS);
   button->SetImage(views::Button::STATE_NORMAL,
                    *GetImageSkiaNamed(IDR_BOOKMARK_BAR_FOLDER));
   button->set_context_menu_controller(this);
   button->set_tag(kOtherFolderButtonTag);
   return button;
 }
@@ skipping 200 matching lines @@
   *location = DropLocation();
 
   // The drop event uses the screen coordinates while the child Views are
   // always laid out from left to right (even though they are rendered from
   // right-to-left on RTL locales). Thus, in order to make sure the drop
   // coordinates calculation works, we mirror the event's X coordinate if the
   // locale is RTL.
   int mirrored_x = GetMirroredXInView(event.x());
 
   bool found = false;
-  const int other_delta_x = mirrored_x - other_bookmarked_button_->x();
+  const int other_delta_x = mirrored_x - other_bookmarks_button_->x();
   Profile* profile = browser_->profile();
-  if (other_bookmarked_button_->visible() && other_delta_x >= 0 &&
-      other_delta_x < other_bookmarked_button_->width()) {
+  if (other_bookmarks_button_->visible() && other_delta_x >= 0 &&
+      other_delta_x < other_bookmarks_button_->width()) {
     // Mouse is over 'other' folder.
     location->button_type = DROP_OTHER_FOLDER;
     location->on = true;
     found = true;
   } else if (!GetBookmarkButtonCount()) {
     // No bookmarks, accept the drop.
     location->index = 0;
     const BookmarkNode* node = data.GetFirstNode(model_, profile->GetPath());
     int ops = node && client_->CanBeEditedByUser(node) ?
         ui::DragDropTypes::DRAG_MOVE :
@@ skipping 38 matching lines @@
         // Mouse is over overflow button.
         location->index = GetFirstHiddenNodeIndex();
         location->button_type = DROP_OVERFLOW;
       } else if (overflow_delta_x < 0) {
         // Mouse is after the last visible button but before overflow button;
         // use the last visible index.
         location->index = GetFirstHiddenNodeIndex();
       } else {
         return;
       }
-    } else if (!other_bookmarked_button_->visible() ||
-               mirrored_x < other_bookmarked_button_->x()) {
+    } else if (!other_bookmarks_button_->visible() ||
+               mirrored_x < other_bookmarks_button_->x()) {
       // Mouse is after the last visible button but before more recently
       // bookmarked; use the last visible index.
       location->index = GetFirstHiddenNodeIndex();
     } else {
       return;
     }
   }
 
   if (location->on) {
     const BookmarkNode* parent = (location->button_type == DROP_OTHER_FOLDER) ?
@@ skipping 37 matching lines @@
     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*>(child_at(index));
     }
   } else if (client_->IsDescendantOfManagedNode(node)) {
     throbbing_view_ = managed_bookmarks_button_;
   } else if (!overflow_only) {
-    throbbing_view_ = other_bookmarked_button_;
+    throbbing_view_ = other_bookmarks_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) {
@@ skipping 10 matching lines @@
   }
   if (old_node) {
     if (old_index_on_bb >= GetFirstHiddenNodeIndex()) {
       // Node is hidden, animate the overflow button.
       return overflow_button_;
     }
     return static_cast<CustomButton*>(child_at(old_index_on_bb));
   }
   if (client_->IsDescendantOfManagedNode(parent))
     return managed_bookmarks_button_;
-  // Node wasn't on the bookmark bar, use the other bookmark button.
-  return other_bookmarked_button_;
+  // Node wasn't on the bookmark bar, use the "Other Bookmarks" button.
+  return other_bookmarks_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;
   SkColor color =
       theme_provider->GetColor(ThemeProperties::COLOR_BOOKMARK_TEXT);
   for (int i = 0; i < GetBookmarkButtonCount(); ++i)
     GetBookmarkButton(i)->SetTextColor(views::Button::STATE_NORMAL, color);
-  other_bookmarked_button_->SetTextColor(views::Button::STATE_NORMAL, color);
+  other_bookmarks_button_->SetTextColor(views::Button::STATE_NORMAL, color);
   managed_bookmarks_button_->SetTextColor(views::Button::STATE_NORMAL, color);
   if (apps_page_shortcut_->visible())
     apps_page_shortcut_->SetTextColor(views::Button::STATE_NORMAL, color);
 }
 
 bool BookmarkBarView::UpdateOtherAndManagedButtonsVisibility() {
   bool has_other_children = !model_->other_node()->empty();
-  bool update_other = has_other_children != other_bookmarked_button_->visible();
+  bool update_other = has_other_children != other_bookmarks_button_->visible();
   if (update_other) {
-    other_bookmarked_button_->SetVisible(has_other_children);
+    other_bookmarks_button_->SetVisible(has_other_children);
     UpdateBookmarksSeparatorVisibility();
   }
 
   bool show_managed = !client_->managed_node()->empty() &&
                       browser_->profile()->GetPrefs()->GetBoolean(
                           bookmarks::prefs::kShowManagedBookmarksInBookmarkBar);
   bool update_managed = show_managed != managed_bookmarks_button_->visible();
   if (update_managed)
     managed_bookmarks_button_->SetVisible(show_managed);
 
   return update_other || update_managed;
 }
 
 void BookmarkBarView::UpdateBookmarksSeparatorVisibility() {
   // Ash does not paint the bookmarks separator line because it looks odd on
   // the flat background.  We keep it present for layout, but don't draw it.
   bookmarks_separator_view_->SetVisible(
       browser_->host_desktop_type() != chrome::HOST_DESKTOP_TYPE_ASH &&
-      other_bookmarked_button_->visible());
+      other_bookmarks_button_->visible());
 }
 
 void BookmarkBarView::OnAppsPageShortcutVisibilityPrefChanged() {
   DCHECK(apps_page_shortcut_);
   // Only perform layout if required.
   bool visible = chrome::ShouldShowAppsShortcutInBookmarkBar(
       browser_->profile(), browser_->host_desktop_type());
   if (apps_page_shortcut_->visible() == visible)
     return;
   apps_page_shortcut_->SetVisible(visible);
   UpdateBookmarksSeparatorVisibility();
   LayoutAndPaint();
 }
 
 void BookmarkBarView::OnShowManagedBookmarksPrefChanged() {
   if (UpdateOtherAndManagedButtonsVisibility())
     LayoutAndPaint();
 }