Cleans up bookmark_bar_view. In particular makes sure order of methods

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 325 matching lines @@
   return *kFolderIcon;
 }
 
 BookmarkBarView::BookmarkBarView(Profile* profile, Browser* browser)
     : profile_(NULL),
       page_navigator_(NULL),
       model_(NULL),
       bookmark_menu_(NULL),
       bookmark_drop_menu_(NULL),
       other_bookmarked_button_(NULL),
-      model_changed_listener_(NULL),
       show_folder_drop_menu_task_(NULL),
       sync_error_button_(NULL),
       sync_service_(NULL),
       overflow_button_(NULL),
       instructions_(NULL),
       bookmarks_separator_view_(NULL),
       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);
   Init();
   SetProfile(profile);
 
   size_animation_->Reset(IsAlwaysShown() ? 1 : 0);
 }
 
 BookmarkBarView::~BookmarkBarView() {
-  NotifyModelChanged();
   if (model_)
     model_->RemoveObserver(this);
 
   // It's possible for the menu to outlive us, reset the observer to make sure
   // it doesn't have a reference to us.
   if (bookmark_menu_)
     bookmark_menu_->set_observer(NULL);
 
   StopShowFolderDropMenuTimer();
 
   if (sync_service_)
     sync_service_->RemoveObserver(this);
 }
 
 void BookmarkBarView::SetProfile(Profile* profile) {
   DCHECK(profile);
   if (profile_ == profile)
     return;
 
   StopThrobbing(true);
 
   // Cancels the current cancelable.
-  NotifyModelChanged();
   registrar_.RemoveAll();
 
   profile_ = profile;
 
   if (model_)
     model_->RemoveObserver(this);
 
   // Disable the other bookmarked button, we'll re-enable when the model is
   // loaded.
   other_bookmarked_button_->SetEnabled(false);
@@ skipping 15 matching lines @@
       Loaded(model_);
     // else case: we'll receive notification back from the BookmarkModel when
     // done loading, then we'll populate the bar.
   }
 }
 
 void BookmarkBarView::SetPageNavigator(PageNavigator* navigator) {
   page_navigator_ = navigator;
 }
 
+void BookmarkBarView::OnFullscreenToggled(bool fullscreen) {
+  if (!fullscreen)
+    size_animation_->Reset(IsAlwaysShown() ? 1 : 0);
+  else if (IsAlwaysShown())
+    size_animation_->Reset(0);
+}
+
+bool BookmarkBarView::IsAlwaysShown() const {
+  return (profile_->GetPrefs()->GetBoolean(prefs::kShowBookmarkBar) &&
+          profile_->GetPrefs()->GetBoolean(prefs::kEnableBookmarkBar));
+}
+
+bool BookmarkBarView::OnNewTabPage() const {
+  return (browser_ && browser_->GetSelectedTabContents() &&
+          browser_->GetSelectedTabContents()->ShouldShowBookmarkBar());
+}
+
+int BookmarkBarView::GetToolbarOverlap(bool return_max) const {
+  // When not on the New Tab Page, always overlap by the full amount.
+  if (return_max || !OnNewTabPage())
+    return kToolbarOverlap;
+  // When on the New Tab Page with an infobar, overlap by 0 whenever the infobar
+  // is above us (i.e. when we're detached), since drawing over the infobar
+  // looks weird.
+  if (IsDetached() && infobar_visible_)
+    return 0;
+  // When on the New Tab Page with no infobar, animate the overlap between the
+  // attached and detached states.
+  return static_cast<int>(kToolbarOverlap * size_animation_->GetCurrentValue());
+}
+
+bool BookmarkBarView::is_animating() {
+  return size_animation_->is_animating();
+}
+
+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));
+}
+
+const BookmarkNode* BookmarkBarView::GetNodeForButtonAt(const gfx::Point& loc,
+                                                        int* start_index) {
+  *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())
+      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)) {
+    *start_index = GetFirstHiddenNodeIndex();
+    return model_->GetBookmarkBarNode();
+  }
+
+  // And finally the other folder.
+  if (other_bookmarked_button_->IsVisible() &&
+      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())
+    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));
+}
+
+void BookmarkBarView::GetAnchorPositionAndStartIndexForButton(
+    views::MenuButton* button,
+    MenuItemView::AnchorPosition* anchor,
+    int* start_index) {
+  if (button == other_bookmarked_button_ || button == overflow_button_)
+    *anchor = MenuItemView::TOPRIGHT;
+  else
+    *anchor = MenuItemView::TOPLEFT;
+
+  // Invert orientation if right to left.
+  if (base::i18n::IsRTL()) {
+    if (*anchor == MenuItemView::TOPRIGHT)
+      *anchor = MenuItemView::TOPLEFT;
+    else
+      *anchor = MenuItemView::TOPRIGHT;
+  }
+
+  if (button == overflow_button_)
+    *start_index = GetFirstHiddenNodeIndex();
+  else
+    *start_index = 0;
+}
+
+views::MenuItemView* BookmarkBarView::GetMenu() {
+  return bookmark_menu_ ? bookmark_menu_->menu() : NULL;
+}
+
+views::MenuItemView* BookmarkBarView::GetContextMenu() {
+  return bookmark_menu_ ? bookmark_menu_->context_menu() : NULL;
+}
+
+views::MenuItemView* BookmarkBarView::GetDropMenu() {
+  return bookmark_drop_menu_ ? bookmark_drop_menu_->menu() : NULL;
+}
+
+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;
+}
+
+// static
+std::wstring BookmarkBarView::CreateToolTipForURLAndTitle(
+    const gfx::Point& screen_loc,
+    const GURL& url,
+    const std::wstring& title,
+    Profile* profile) {
+  int max_width = views::TooltipManager::GetMaxWidth(screen_loc.x(),
+                                                     screen_loc.y());
+  gfx::Font tt_font = views::TooltipManager::GetDefaultFont();
+  string16 result;
+
+  // First the title.
+  if (!title.empty()) {
+    string16 localized_title = WideToUTF16(title);
+    base::i18n::AdjustStringForLocaleDirection(&localized_title);
+    result.append(ui::ElideText(localized_title, tt_font, max_width, false));
+  }
+
+  // Only show the URL if the url and title differ.
+  if (title != UTF8ToWide(url.spec())) {
+    if (!result.empty())
+      result.append(WideToUTF16(views::TooltipManager::GetLineSeparator()));
+
+    // We need to explicitly specify the directionality of the URL's text to
+    // make sure it is treated as an LTR string when the context is RTL. For
+    // example, the URL "http://www.yahoo.com/" appears as
+    // "/http://www.yahoo.com" when rendered, as is, in an RTL context since
+    // the Unicode BiDi algorithm puts certain characters on the left by
+    // default.
+    std::string languages = profile->GetPrefs()->GetString(
+        prefs::kAcceptLanguages);
+    string16 elided_url(ui::ElideUrl(url, tt_font, max_width, languages));
+    elided_url = base::i18n::GetDisplayStringInLTRDirectionality(elided_url);
+    result.append(elided_url);
+  }
+  return UTF16ToWide(result);
+}
+
+bool BookmarkBarView::IsDetached() const {
+  if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kNewTabPage4))
+    return false;
+
+  return OnNewTabPage() && (size_animation_->GetCurrentValue() != 1);
+}
+
+double BookmarkBarView::GetAnimationValue() const {
+  return size_animation_->GetCurrentValue();
+}
+
+int BookmarkBarView::GetToolbarOverlap() const {
+  return GetToolbarOverlap(false);
+}
+
 gfx::Size BookmarkBarView::GetPreferredSize() {
   return LayoutItems(true);
 }
 
 gfx::Size BookmarkBarView::GetMinimumSize() {
   // The minimum width of the bookmark bar should at least contain the overflow
   // button, by which one can access all the Bookmark Bar items, and the "Other
   // Bookmarks" folder, along with appropriate margins and button padding.
   int width = kLeftMargin;
 
@@ skipping 226 matching lines @@
   }
   return bookmark_utils::PerformBookmarkDrop(profile_, data, parent_node,
                                              index);
 }
 
 void BookmarkBarView::ShowContextMenu(const gfx::Point& p,
                                       bool is_mouse_gesture) {
   ShowContextMenuForView(this, p, is_mouse_gesture);
 }
 
+void BookmarkBarView::OnThemeChanged() {
+  UpdateColors();
+}
+
 void BookmarkBarView::GetAccessibleState(ui::AccessibleViewState* state) {
   state->role = ui::AccessibilityTypes::ROLE_TOOLBAR;
   state->name = l10n_util::GetStringUTF16(IDS_ACCNAME_BOOKMARKS);
 }
 
 void BookmarkBarView::OnStateChanged() {
   // When the sync state changes, it is sufficient to invoke View::Layout since
   // during layout we query the profile sync service and determine whether the
   // new state requires showing the sync error button so that the user can
   // re-enter her password. If extension shelf appears along with the bookmark
   // shelf, it too needs to be layed out. Since both have the same parent, it is
   // enough to let the parent layout both of these children.
   // TODO(sky): This should not require Layout() and SchedulePaint(). Needs
   //            some cleanup.
   PreferredSizeChanged();
   Layout();
   SchedulePaint();
 }
 
-void BookmarkBarView::OnFullscreenToggled(bool fullscreen) {
-  if (!fullscreen)
-    size_animation_->Reset(IsAlwaysShown() ? 1 : 0);
-  else if (IsAlwaysShown())
-    size_animation_->Reset(0);
-}
-
-bool BookmarkBarView::IsDetached() const {
-  if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kNewTabPage4))
-    return false;
-
-  return OnNewTabPage() && (size_animation_->GetCurrentValue() != 1);
-}
-
-bool BookmarkBarView::IsOnTop() const {
-  return true;
-}
-
-double BookmarkBarView::GetAnimationValue() const {
-  return size_animation_->GetCurrentValue();
-}
-
-int BookmarkBarView::GetToolbarOverlap() const {
-  return GetToolbarOverlap(false);
-}
-
-bool BookmarkBarView::IsAlwaysShown() const {
-  return (profile_->GetPrefs()->GetBoolean(prefs::kShowBookmarkBar) &&
-          profile_->GetPrefs()->GetBoolean(prefs::kEnableBookmarkBar));
-}
-
-bool BookmarkBarView::OnNewTabPage() const {
-  return (browser_ && browser_->GetSelectedTabContents() &&
-          browser_->GetSelectedTabContents()->ShouldShowBookmarkBar());
-}
-
-int BookmarkBarView::GetToolbarOverlap(bool return_max) const {
-  // When not on the New Tab Page, always overlap by the full amount.
-  if (return_max || !OnNewTabPage())
-    return kToolbarOverlap;
-  // When on the New Tab Page with an infobar, overlap by 0 whenever the infobar
-  // is above us (i.e. when we're detached), since drawing over the infobar
-  // looks weird.
-  if (IsDetached() && infobar_visible_)
-    return 0;
-  // When on the New Tab Page with no infobar, animate the overlap between the
-  // attached and detached states.
-  return static_cast<int>(kToolbarOverlap * size_animation_->GetCurrentValue());
-}
-
-bool BookmarkBarView::is_animating() {
-  return size_animation_->is_animating();
-}
-
 void BookmarkBarView::AnimationProgressed(const ui::Animation* animation) {
   if (browser_)
     browser_->BookmarkBarSizeChanged(true);
 }
 
 void BookmarkBarView::AnimationEnded(const ui::Animation* animation) {
   if (browser_)
     browser_->BookmarkBarSizeChanged(false);
 
   SchedulePaint();
 }
 
 void BookmarkBarView::BookmarkMenuDeleted(BookmarkMenuController* controller) {
   if (controller == bookmark_menu_)
     bookmark_menu_ = NULL;
   else if (controller == bookmark_drop_menu_)
     bookmark_drop_menu_ = NULL;
 }
 
-views::TextButton* BookmarkBarView::GetBookmarkButton(int index) {
-  DCHECK(index >= 0 && index < GetBookmarkButtonCount());
-  return static_cast<views::TextButton*>(GetChildViewAt(index));
-}
-
-views::MenuItemView* BookmarkBarView::GetMenu() {
-  return bookmark_menu_ ? bookmark_menu_->menu() : NULL;
-}
-
-views::MenuItemView* BookmarkBarView::GetContextMenu() {
-  return bookmark_menu_ ? bookmark_menu_->context_menu() : NULL;
-}
-
-views::MenuItemView* BookmarkBarView::GetDropMenu() {
-  return bookmark_drop_menu_ ? bookmark_drop_menu_->menu() : NULL;
-}
-
-const BookmarkNode* BookmarkBarView::GetNodeForButtonAt(const gfx::Point& loc,
-                                                        int* start_index) {
-  *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())
-      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)) {
-    *start_index = GetFirstHiddenNodeIndex();
-    return model_->GetBookmarkBarNode();
-  }
-
-  // And finally the other folder.
-  if (other_bookmarked_button_->IsVisible() &&
-      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())
-    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));
-}
-
-void BookmarkBarView::GetAnchorPositionAndStartIndexForButton(
-    views::MenuButton* button,
-    MenuItemView::AnchorPosition* anchor,
-    int* start_index) {
-  if (button == other_bookmarked_button_ || button == overflow_button_)
-    *anchor = MenuItemView::TOPRIGHT;
-  else
-    *anchor = MenuItemView::TOPLEFT;
-
-  // Invert orientation if right to left.
-  if (base::i18n::IsRTL()) {
-    if (*anchor == MenuItemView::TOPRIGHT)
-      *anchor = MenuItemView::TOPLEFT;
-    else
-      *anchor = MenuItemView::TOPRIGHT;
-  }
-
-  if (button == overflow_button_)
-    *start_index = GetFirstHiddenNodeIndex();
-  else
-    *start_index = 0;
-}
-
 void BookmarkBarView::ShowImportDialog() {
   browser_->OpenImportSettingsDialog();
 }
 
-void BookmarkBarView::Init() {
-  // 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.
-
-  ResourceBundle& rb = ResourceBundle::GetSharedInstance();
-
-  if (!kDefaultFavicon)
-    kDefaultFavicon = rb.GetBitmapNamed(IDR_DEFAULT_FAVICON);
-
-  // Child views are traversed in the order they are added. Make sure the order
-  // they are added matches the visual order.
-  sync_error_button_ = CreateSyncErrorButton();
-  AddChildView(sync_error_button_);
-
-  overflow_button_ = CreateOverflowButton();
-  AddChildView(overflow_button_);
-
-  other_bookmarked_button_ = CreateOtherBookmarkedButton();
-  AddChildView(other_bookmarked_button_);
-
-  bookmarks_separator_view_ = new ButtonSeparatorView();
-  AddChildView(bookmarks_separator_view_);
-
-  instructions_ = new BookmarkBarInstructionsView(this);
-  AddChildView(instructions_);
-
-  SetContextMenuController(this);
-
-  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->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);
-  button->SetIcon(*ResourceBundle::GetSharedInstance().
-                  GetBitmapNamed(IDR_BOOKMARK_BAR_CHEVRONS));
-
-  // The overflow button's image contains an arrow and therefore it is a
-  // direction sensitive image and we need to flip it if the UI layout is
-  // right-to-left.
-  //
-  // By default, menu buttons are not flipped because they generally contain
-  // text and flipping the gfx::Canvas object will break text rendering. Since
-  // the overflow button does not contain text, we can safely flip it.
-  button->EnableCanvasFlippingForRTLUI(true);
-
-  // Make visible as necessary.
-  button->SetVisible(false);
-  // Set accessibility name.
-  button->SetAccessibleName(
-      l10n_util::GetStringUTF16(IDS_ACCNAME_BOOKMARKS_CHEVRON));
-  return button;
-}
-
 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->child_count(); i < child_count; ++i)
     AddChildViewAt(CreateBookmarkButton(node->GetChild(i)), i);
   UpdateColors();
   UpdateOtherBookmarksVisibility();
   other_bookmarked_button_->SetEnabled(true);
 
   Layout();
   SchedulePaint();
 }
 
 void BookmarkBarView::BookmarkModelBeingDeleted(BookmarkModel* model) {
   // In normal shutdown The bookmark model should never be deleted before us.
   // When X exits suddenly though, it can happen, This code exists
   // to check for regressions in shutdown code and not crash.
   if (!browser_shutdown::ShuttingDownWithoutClosingBrowsers())
     NOTREACHED();
 
   // Do minimal cleanup, presumably we'll be deleted shortly.
-  NotifyModelChanged();
   model_->RemoveObserver(this);
   model_ = NULL;
 }
 
 void BookmarkBarView::BookmarkNodeMoved(BookmarkModel* model,
                                         const BookmarkNode* old_parent,
                                         int old_index,
                                         const BookmarkNode* new_parent,
                                         int new_index) {
   bool was_throbbing = throbbing_view_ &&
       throbbing_view_ == DetermineViewToThrobFromRemove(old_parent, old_index);
   if (was_throbbing)
     throbbing_view_->StopThrobbing();
   BookmarkNodeRemovedImpl(model, old_parent, old_index);
   BookmarkNodeAddedImpl(model, new_parent, new_index);
   if (was_throbbing)
     StartThrobbing(new_parent->GetChild(new_index), false);
 }
 
 void BookmarkBarView::BookmarkNodeAdded(BookmarkModel* model,
                                         const BookmarkNode* parent,
                                         int index) {
   BookmarkNodeAddedImpl(model, parent, index);
 }
 
-void BookmarkBarView::BookmarkNodeAddedImpl(BookmarkModel* model,
-                                            const BookmarkNode* parent,
-                                            int index) {
-  UpdateOtherBookmarksVisibility();
-  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);
-  }
-  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);
 }
 
-void BookmarkBarView::BookmarkNodeRemovedImpl(BookmarkModel* model,
-                                              const BookmarkNode* parent,
-                                              int index) {
-  UpdateOtherBookmarksVisibility();
-
-  StopThrobbing(true);
-  // No need to start throbbing again as the bookmark bubble can't be up at
-  // the same time as the user reorders.
-
-  NotifyModelChanged();
-  if (parent != model_->GetBookmarkBarNode()) {
-    // We only care about nodes on the bookmark bar.
-    return;
-  }
-  DCHECK(index >= 0 && index < GetBookmarkButtonCount());
-  views::View* button = GetChildViewAt(index);
-  RemoveChildView(button);
-  MessageLoop::current()->DeleteSoon(FROM_HERE, button);
-  Layout();
-  SchedulePaint();
-}
-
 void BookmarkBarView::BookmarkNodeChanged(BookmarkModel* model,
                                           const BookmarkNode* node) {
-  NotifyModelChanged();
   BookmarkNodeChangedImpl(model, node);
 }
 
-void BookmarkBarView::BookmarkNodeChangedImpl(BookmarkModel* model,
-                                              const BookmarkNode* node) {
-  if (node->parent() != model_->GetBookmarkBarNode()) {
-    // We only care about nodes on the bookmark bar.
-    return;
-  }
-  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()) {
-    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.
 
   // Remove the existing buttons.
   while (GetBookmarkButtonCount()) {
     views::View* button = GetChildViewAt(0);
     RemoveChildView(button);
     MessageLoop::current()->DeleteSoon(FROM_HERE, button);
   }
 
@@ skipping 68 matching lines @@
           menu_button->Activate();
           return false;
         }
         break;
       }
     }
   }
   return true;
 }
 
-void BookmarkBarView::WriteBookmarkDragData(const BookmarkNode* node,
-                                            ui::OSExchangeData* data) {
-  DCHECK(node && data);
-  BookmarkNodeData drag_data(node);
-  drag_data.Write(profile_, data);
-}
-
 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 {
@@ skipping 72 matching lines @@
     nodes.push_back(parent);
   }
   // Browser may be null during testing.
   PageNavigator* navigator =
       browser() ? browser()->GetSelectedTabContents() : NULL;
   BookmarkContextMenu controller(GetWindow()->GetNativeWindow(), GetProfile(),
                                  navigator, parent, nodes);
   controller.RunMenuAt(p);
 }
 
+void BookmarkBarView::Observe(NotificationType type,
+                              const NotificationSource& source,
+                              const NotificationDetails& details) {
+  DCHECK(profile_);
+  switch (type.value) {
+    case NotificationType::BOOKMARK_BAR_VISIBILITY_PREF_CHANGED:
+      if (IsAlwaysShown()) {
+        size_animation_->Show();
+      } else {
+        size_animation_->Hide();
+      }
+      break;
+
+    case NotificationType::BOOKMARK_BUBBLE_SHOWN: {
+      StopThrobbing(true);
+      GURL url = *(Details<GURL>(details).ptr());
+      const BookmarkNode* node = model_->GetMostRecentlyAddedNodeForURL(url);
+      if (!node)
+        return;  // Generally shouldn't happen.
+      StartThrobbing(node, false);
+      break;
+    }
+    case NotificationType::BOOKMARK_BUBBLE_HIDDEN:
+      StopThrobbing(false);
+      break;
+
+    default:
+      NOTREACHED();
+      break;
+  }
+}
+
+void BookmarkBarView::Init() {
+  // 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.
+
+  ResourceBundle& rb = ResourceBundle::GetSharedInstance();
+
+  if (!kDefaultFavicon)
+    kDefaultFavicon = rb.GetBitmapNamed(IDR_DEFAULT_FAVICON);
+
+  // Child views are traversed in the order they are added. Make sure the order
+  // they are added matches the visual order.
+  sync_error_button_ = CreateSyncErrorButton();
+  AddChildView(sync_error_button_);
+
+  overflow_button_ = CreateOverflowButton();
+  AddChildView(overflow_button_);
+
+  other_bookmarked_button_ = CreateOtherBookmarkedButton();
+  AddChildView(other_bookmarked_button_);
+
+  bookmarks_separator_view_ = new ButtonSeparatorView();
+  AddChildView(bookmarks_separator_view_);
+
+  instructions_ = new BookmarkBarInstructionsView(this);
+  AddChildView(instructions_);
+
+  SetContextMenuController(this);
+
+  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->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);
+  button->SetIcon(*ResourceBundle::GetSharedInstance().
+                  GetBitmapNamed(IDR_BOOKMARK_BAR_CHEVRONS));
+
+  // The overflow button's image contains an arrow and therefore it is a
+  // direction sensitive image and we need to flip it if the UI layout is
+  // right-to-left.
+  //
+  // By default, menu buttons are not flipped because they generally contain
+  // text and flipping the gfx::Canvas object will break text rendering. Since
+  // the overflow button does not contain text, we can safely flip it.
+  button->EnableCanvasFlippingForRTLUI(true);
+
+  // Make visible as necessary.
+  button->SetVisible(false);
+  // Set accessibility name.
+  button->SetAccessibleName(
+      l10n_util::GetStringUTF16(IDS_ACCNAME_BOOKMARKS_CHEVRON));
+  return button;
+}
+
+views::TextButton* BookmarkBarView::CreateSyncErrorButton() {
+  views::TextButton* sync_error_button =
+      new views::TextButton(this, UTF16ToWide(
+          l10n_util::GetStringUTF16(IDS_SYNC_BOOKMARK_BAR_ERROR)));
+  sync_error_button->set_tag(kSyncErrorButtonTag);
+
+  // 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;
+}
+
 views::View* BookmarkBarView::CreateBookmarkButton(const BookmarkNode* node) {
   if (node->is_url()) {
     BookmarkButton* button = new BookmarkButton(this, node->GetURL(),
         UTF16ToWide(node->GetTitle()), GetProfile());
     ConfigureButton(node, button);
     return button;
   } else {
     views::MenuButton* button = new BookmarkFolderButton(this,
         UTF16ToWide(node->GetTitle()), this, false);
     button->SetIcon(GetFolderIcon());
@@ skipping 18 matching lines @@
   button->SetDragController(this);
   if (node->is_url()) {
     if (model_->GetFavicon(node).width() != 0)
       button->SetIcon(model_->GetFavicon(node));
     else
       button->SetIcon(*kDefaultFavicon);
   }
   button->set_max_width(kMaxButtonWidth);
 }
 
-bool BookmarkBarView::IsItemChecked(int id) const {
-  DCHECK(id == kAlwaysShowCommandID);
-  return profile_->GetPrefs()->GetBoolean(prefs::kShowBookmarkBar);
+void BookmarkBarView::BookmarkNodeAddedImpl(BookmarkModel* model,
+                                            const BookmarkNode* parent,
+                                            int index) {
+  UpdateOtherBookmarksVisibility();
+  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);
+  }
+  AddChildViewAt(CreateBookmarkButton(node), index);
+  UpdateColors();
+  Layout();
+  SchedulePaint();
 }
 
-void BookmarkBarView::ExecuteCommand(int id) {
-  bookmark_utils::ToggleWhenVisible(profile_);
+void BookmarkBarView::BookmarkNodeRemovedImpl(BookmarkModel* model,
+                                              const BookmarkNode* parent,
+                                              int index) {
+  UpdateOtherBookmarksVisibility();
+
+  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);
+  RemoveChildView(button);
+  MessageLoop::current()->DeleteSoon(FROM_HERE, button);
+  Layout();
+  SchedulePaint();
 }
 
-void BookmarkBarView::Observe(NotificationType type,
-                              const NotificationSource& source,
-                              const NotificationDetails& details) {
-  DCHECK(profile_);
-  switch (type.value) {
-    case NotificationType::BOOKMARK_BAR_VISIBILITY_PREF_CHANGED:
-      if (IsAlwaysShown()) {
-        size_animation_->Show();
-      } else {
-        size_animation_->Hide();
-      }
-      break;
-
-    case NotificationType::BOOKMARK_BUBBLE_SHOWN: {
-      StopThrobbing(true);
-      GURL url = *(Details<GURL>(details).ptr());
-      const BookmarkNode* node = model_->GetMostRecentlyAddedNodeForURL(url);
-      if (!node)
-        return;  // Generally shouldn't happen.
-      StartThrobbing(node, false);
-      break;
-    }
-    case NotificationType::BOOKMARK_BUBBLE_HIDDEN:
-      StopThrobbing(false);
-      break;
-
-    default:
-      NOTREACHED();
-      break;
+void BookmarkBarView::BookmarkNodeChangedImpl(BookmarkModel* model,
+                                              const BookmarkNode* node) {
+  if (node->parent() != model_->GetBookmarkBarNode()) {
+    // We only care about nodes on the bookmark bar.
+    return;
+  }
+  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()) {
+    button->SchedulePaint();
   }
 }
 
-void BookmarkBarView::OnThemeChanged() {
-  UpdateColors();
-}
-
-void BookmarkBarView::NotifyModelChanged() {
-  if (model_changed_listener_)
-    model_changed_listener_->ModelChanged();
-}
-
 void BookmarkBarView::ShowDropFolderForNode(const BookmarkNode* node) {
   if (bookmark_drop_menu_) {
     if (bookmark_drop_menu_->node() == node) {
       // Already showing for the specified node.
       return;
     }
     bookmark_drop_menu_->Cancel();
   }
 
   views::MenuButton* menu_button = GetMenuButtonForNode(node);
@@ skipping 134 matching lines @@
       // open.
       *drop_on = false;
     }
     return operation;
   }
   return bookmark_utils::BookmarkDropOperation(profile_, event, data,
                                                model_->GetBookmarkBarNode(),
                                                *index);
 }
 
+void BookmarkBarView::WriteBookmarkDragData(const BookmarkNode* node,
+                                            ui::OSExchangeData* data) {
+  DCHECK(node && data);
+  BookmarkNodeData drag_data(node);
+  drag_data.Write(profile_, data);
+}
+
 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;
 }
 
 void BookmarkBarView::StartThrobbing(const BookmarkNode* node,
@@ skipping 45 matching lines @@
     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));
   }
   // Node wasn't on the bookmark bar, use the other bookmark button.
   return other_bookmarked_button_;
 }
 
-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;
-}
-
-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;
-}
-
-// static
-std::wstring BookmarkBarView::CreateToolTipForURLAndTitle(
-    const gfx::Point& screen_loc,
-    const GURL& url,
-    const std::wstring& title,
-    Profile* profile) {
-  int max_width = views::TooltipManager::GetMaxWidth(screen_loc.x(),
-                                                     screen_loc.y());
-  gfx::Font tt_font = views::TooltipManager::GetDefaultFont();
-  string16 result;
-
-  // First the title.
-  if (!title.empty()) {
-    string16 localized_title = WideToUTF16(title);
-    base::i18n::AdjustStringForLocaleDirection(&localized_title);
-    result.append(ui::ElideText(localized_title, tt_font, max_width, false));
-  }
-
-  // Only show the URL if the url and title differ.
-  if (title != UTF8ToWide(url.spec())) {
-    if (!result.empty())
-      result.append(WideToUTF16(views::TooltipManager::GetLineSeparator()));
-
-    // We need to explicitly specify the directionality of the URL's text to
-    // make sure it is treated as an LTR string when the context is RTL. For
-    // example, the URL "http://www.yahoo.com/" appears as
-    // "/http://www.yahoo.com" when rendered, as is, in an RTL context since
-    // the Unicode BiDi algorithm puts certain characters on the left by
-    // default.
-    std::string languages = profile->GetPrefs()->GetString(
-        prefs::kAcceptLanguages);
-    string16 elided_url(ui::ElideUrl(url, tt_font, max_width, languages));
-    elided_url = base::i18n::GetDisplayStringInLTRDirectionality(elided_url);
-    result.append(elided_url);
-  }
-  return UTF16ToWide(result);
-}
-
 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 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);
@@ skipping 147 matching lines @@
       prefsize.set_height(kBarHeight +
           static_cast<int>((kNewtabBarHeight - kBarHeight) *
               (1 - size_animation_->GetCurrentValue())));
     } else {
       prefsize.set_height(
           static_cast<int>(kBarHeight * size_animation_->GetCurrentValue()));
     }
   }
   return prefsize;
 }
-
-views::TextButton* BookmarkBarView::CreateSyncErrorButton() {
-  views::TextButton* sync_error_button =
-      new views::TextButton(this, UTF16ToWide(
-          l10n_util::GetStringUTF16(IDS_SYNC_BOOKMARK_BAR_ERROR)));
-  sync_error_button->set_tag(kSyncErrorButtonTag);
-
-  // 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;
-}