Renames BoomarkBarModel to BookmarkModel.

chrome/browser/views/bookmark_bar_view.cc

 // Copyright (c) 2006-2008 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/views/bookmark_bar_view.h"
 
 #include <limits>
 
 #include "base/base_drag_source.h"
 #include "base/gfx/skia_utils.h"
@@ skipping 175 matching lines @@
                                           monitor_bounds.width(),
                                           languages));
     if (l10n_util::GetTextDirection() == l10n_util::RIGHT_TO_LEFT)
       l10n_util::WrapStringWithLTRFormatting(&elided_url);
     result.append(elided_url);
   }
   return result;
 }
 
 // Returns the drag operations for the specified node.
-static int GetDragOperationsForNode(BookmarkBarNode* node) {
+static int GetDragOperationsForNode(BookmarkNode* node) {
   if (node->GetType() == history::StarredEntry::URL) {
     return DragDropTypes::DRAG_COPY | DragDropTypes::DRAG_MOVE |
            DragDropTypes::DRAG_LINK;
   }
   return DragDropTypes::DRAG_COPY | DragDropTypes::DRAG_MOVE;
 }
 
 // BookmarkButton -------------------------------------------------------------
 
 // Buttons used for the bookmarks on the bookmark bar.
@@ skipping 102 matching lines @@
 
 // MenuRunner manages creation and showing of a menu containing BookmarkNodes.
 // MenuRunner is used to show the contents of bookmark folders on the
 // bookmark bar, other folder, or overflow bookmarks.
 //
 class MenuRunner : public ChromeViews::MenuDelegate,
                    public BookmarkBarView::ModelChangedListener {
  public:
   // start_child_index is the index of the first child in node to add to the
   // menu.
-  MenuRunner(BookmarkBarView* view,
-             BookmarkBarNode* node,
-             int start_child_index)
+  MenuRunner(BookmarkBarView* view, BookmarkNode* node, int start_child_index)
       : view_(view),
         node_(node),
         menu_(this) {
     int next_menu_id = 1;
     menu_id_to_node_map_[menu_.GetCommand()] = node;
     BuildMenu(node, start_child_index, &menu_, &next_menu_id);
   }
 
   // Returns the node the menu is being run for.
-  BookmarkBarNode* GetNode() {
+  BookmarkNode* GetNode() {
     return node_;
   }
 
   void RunMenuAt(HWND hwnd,
                  const gfx::Rect& bounds,
                  MenuItemView::AnchorPosition position,
                  bool for_drop) {
     view_->SetModelChangedListener(this);
     if (for_drop)
       menu_.RunMenuForDropAt(hwnd, bounds, position);
     else
       menu_.RunMenuAt(hwnd, bounds, position, false);
     view_->ClearModelChangedListenerIfEquals(this);
   }
 
   // Notification that the favicon has finished loading. Reset the icon
   // of the menu item.
-  void FavIconLoaded(BookmarkBarNode* node) {
+  void FavIconLoaded(BookmarkNode* node) {
     if (node_to_menu_id_map_.find(node) !=
         node_to_menu_id_map_.end()) {
       menu_.SetIcon(node->GetFavIcon(), node_to_menu_id_map_[node]);
     }
   }
 
   virtual void ModelChanged() {
     if (context_menu_.get())
       context_menu_->ModelChanged();
     menu_.Cancel();
   }
 
   MenuItemView* menu() { return &menu_; }
 
   MenuItemView* context_menu() {
     return context_menu_.get() ? context_menu_->menu() : NULL;
   }
 
  private:
   // Creates an entry in menu for each child node of parent starting at
   // start_child_index, recursively invoking this for any star groups.
-  void BuildMenu(BookmarkBarNode* parent,
+  void BuildMenu(BookmarkNode* parent,
                  int start_child_index,
                  MenuItemView* menu,
                  int* next_menu_id) {
     DCHECK(!parent->GetChildCount() ||
            start_child_index < parent->GetChildCount());
     for (int i = start_child_index; i < parent->GetChildCount(); ++i) {
-      BookmarkBarNode* node = parent->GetChild(i);
+      BookmarkNode* node = parent->GetChild(i);
       int id = *next_menu_id;
 
       (*next_menu_id)++;
       if (node->GetType() == history::StarredEntry::URL) {
         SkBitmap icon = node->GetFavIcon();
         if (icon.width() == 0)
           icon = *kDefaultFavIcon;
         menu->AppendMenuItemWithIcon(id, node->GetTitle(), icon);
         node_to_menu_id_map_[node] = id;
       } else {
@@ skipping 32 matching lines @@
 
     if (drop_data_.is_url)
       return true;
 
     if (drop_data_.profile_id != view_->GetProfile()->GetID()) {
       // Always accept drags of bookmark groups from other profiles.
       return true;
     }
     // Drag originated from same profile and is not a URL. Only accept it if
     // the dragged node is not a parent of the node menu represents.
-    BookmarkBarNode* drop_node = menu_id_to_node_map_[menu->GetCommand()];
+    BookmarkNode* drop_node = menu_id_to_node_map_[menu->GetCommand()];
     DCHECK(drop_node);
-    BookmarkBarNode* drag_node = drop_data_.GetNode(view_->GetProfile()->
-        GetBookmarkBarModel());
+    BookmarkNode* drag_node =
+        drop_data_.GetNode(view_->GetProfile()->GetBookmarkModel());
     if (!drag_node) {
       // Hmmm, can't find the dragged node. This is generally an error
       // condition and we won't try and do anything fancy.
       NOTREACHED();
       return false;
     }
-    BookmarkBarNode* node = drop_node;
+    BookmarkNode* node = drop_node;
     while (drop_node && drop_node != drag_node)
       drop_node = drop_node->GetParent();
     return (drop_node == NULL);
   }
 
   virtual int GetDropOperation(MenuItemView* item,
                                const ChromeViews::DropTargetEvent& event,
                                DropPosition* position) {
     DCHECK(drop_data_.is_valid);
-    BookmarkBarNode* node = menu_id_to_node_map_[item->GetCommand()];
-    BookmarkBarNode* drop_parent = node->GetParent();
+    BookmarkNode* node = menu_id_to_node_map_[item->GetCommand()];
+    BookmarkNode* drop_parent = node->GetParent();
     int index_to_drop_at = drop_parent->IndexOfChild(node);
     if (*position == DROP_AFTER) {
       index_to_drop_at++;
     } else if (*position == DROP_ON) {
       drop_parent = node;
       index_to_drop_at = node->GetChildCount();
     }
     DCHECK(drop_parent);
     return view_->CalculateDropOperation(drop_data_, drop_parent,
                                          index_to_drop_at);
   }
 
   virtual int OnPerformDrop(MenuItemView* menu,
                             DropPosition position,
                             const DropTargetEvent& event) {
-    BookmarkBarNode* drop_node = menu_id_to_node_map_[menu->GetCommand()];
+    BookmarkNode* drop_node = menu_id_to_node_map_[menu->GetCommand()];
     DCHECK(drop_node);
-    BookmarkBarModel* model = view_->GetModel();
+    BookmarkModel* model = view_->GetModel();
     DCHECK(model);
-    BookmarkBarNode* drop_parent = drop_node->GetParent();
+    BookmarkNode* drop_parent = drop_node->GetParent();
     DCHECK(drop_parent);
     int index_to_drop_at = drop_parent->IndexOfChild(drop_node);
     if (position == DROP_AFTER) {
       index_to_drop_at++;
     } else if (position == DROP_ON) {
       DCHECK(drop_node->GetType() != history::StarredEntry::URL);
       drop_parent = drop_node;
       index_to_drop_at = drop_node->GetChildCount();
     }
 
@@ skipping 36 matching lines @@
 
     view_->WriteDragData(menu_id_to_node_map_[sender->GetCommand()], data);
   }
 
   virtual int GetDragOperations(MenuItemView* sender) {
     return GetDragOperationsForNode(
         menu_id_to_node_map_[sender->GetCommand()]);
   }
 
   // The node we're showing the contents of.
-  BookmarkBarNode* node_;
+  BookmarkNode* node_;
 
   // The view that created us.
   BookmarkBarView* view_;
 
   // The menu.
   MenuItemView menu_;
 
-  // Mapping from menu id to the BookmarkBarNode.
-  std::map<int, BookmarkBarNode*> menu_id_to_node_map_;
+  // Mapping from menu id to the BookmarkNode.
+  std::map<int, BookmarkNode*> menu_id_to_node_map_;
 
   // Mapping from node to menu id. This only contains entries for nodes of type
   // URL.
-  std::map<BookmarkBarNode*, int> node_to_menu_id_map_;
+  std::map<BookmarkNode*, int> node_to_menu_id_map_;
 
   // Data for the drop.
   BookmarkDragData drop_data_;
 
   scoped_ptr<BookmarkBarContextMenuController> context_menu_;
 
   DISALLOW_COPY_AND_ASSIGN(MenuRunner);
 };
 
 // ButtonSeparatorView  --------------------------------------------------------
@@ skipping 118 matching lines @@
   // loaded.
   other_bookmarked_button_->SetEnabled(false);
 
   NotificationService* ns = NotificationService::current();
   Source<Profile> ns_source(profile_->GetOriginalProfile());
   ns->AddObserver(this, NOTIFY_BOOKMARK_BUBBLE_SHOWN, ns_source);
   ns->AddObserver(this, NOTIFY_BOOKMARK_BUBBLE_HIDDEN, ns_source);
   ns->AddObserver(this, NOTIFY_BOOKMARK_BAR_VISIBILITY_PREF_CHANGED,
                   NotificationService::AllSources());
 
-  model_ = profile_->GetBookmarkBarModel();
+  model_ = profile_->GetBookmarkModel();
   model_->AddObserver(this);
   if (model_->IsLoaded())
     Loaded(model_);
-  // else case: we'll receive notification back from the BookmarkBarModel when
-  // done loading, then we'll populate the bar.
+  // 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::GetPreferredSize(CSize *out) {
   if (!prefButtonHeight) {
     ChromeViews::TextButton text_button(L"X");
     CSize text_button_pref;
@@ skipping 269 matching lines @@
   drop_info_->drop_on = drop_on;
   drop_info_->is_over_overflow = is_over_overflow;
   drop_info_->is_over_other = is_over_other;
 
   if (drop_info_->is_menu_showing) {
     drop_menu_runner_.reset();
     drop_info_->is_menu_showing = false;
   }
 
   if (drop_on || is_over_overflow || is_over_other) {
-    BookmarkBarNode* node;
+    BookmarkNode* node;
     if (is_over_other)
       node = model_->other_node();
     else if (is_over_overflow)
       node = model_->GetBookmarkBarNode();
     else
       node = model_->GetBookmarkBarNode()->GetChild(drop_index);
     StartShowFolderDropMenuTimer(node);
   }
 
   return drop_info_->drag_operation;
@@ skipping 15 matching lines @@
 }
 
 int BookmarkBarView::OnPerformDrop(const DropTargetEvent& event) {
   StopShowFolderDropMenuTimer();
 
   drop_menu_runner_.reset();
 
   if (!drop_info_.get() || !drop_info_->drag_operation)
     return DragDropTypes::DRAG_NONE;
 
-  BookmarkBarNode* root =
-      drop_info_->is_over_other ? model_->other_node() :
-                                  model_->GetBookmarkBarNode();
+  BookmarkNode* root = drop_info_->is_over_other ? model_->other_node() :
+                                                   model_->GetBookmarkBarNode();
   int index = drop_info_->drop_index;
   const bool drop_on = drop_info_->drop_on;
   const BookmarkDragData data = drop_info_->data;
   const bool is_over_other = drop_info_->is_over_other;
   DCHECK(data.is_valid);
 
   if (drop_info_->drop_index != -1) {
     // TODO(sky): optimize the SchedulePaint region.
     SchedulePaint();
   }
   drop_info_.reset();
 
-  BookmarkBarNode* parent_node;
+  BookmarkNode* parent_node;
   if (is_over_other) {
     parent_node = root;
     index = parent_node->GetChildCount();
   } else if (drop_on) {
     parent_node = root->GetChild(index);
     index = parent_node->GetChildCount();
   } else {
     parent_node = root;
   }
   return PerformDropImpl(data, parent_node, index);
@@ skipping 110 matching lines @@
   return button;
 }
 
 int BookmarkBarView::GetBookmarkButtonCount() {
   // We contain four non-bookmark button views: recently bookmarked,
   // bookmarks separator, chevrons (for overflow) and the instruction
   // label.
   return GetChildViewCount() - 4;
 }
 
-void BookmarkBarView::Loaded(BookmarkBarModel* model) {
-  BookmarkBarNode* node = model_->GetBookmarkBarNode();
+void BookmarkBarView::Loaded(BookmarkModel* model) {
+  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; i < node->GetChildCount(); ++i)
     AddChildView(i, CreateBookmarkButton(node->GetChild(i)));
   other_bookmarked_button_->SetEnabled(true);
   Layout();
   SchedulePaint();
 }
 
-void BookmarkBarView::BookmarkModelBeingDeleted(BookmarkBarModel* model) {
+void BookmarkBarView::BookmarkModelBeingDeleted(BookmarkModel* model) {
   // The bookmark model should never be deleted before us. This code exists
   // to check for regressions in shutdown code and not crash.
   NOTREACHED();
 
   // Do minimal cleanup, presumably we'll be deleted shortly.
   NotifyModelChanged();
   model_->RemoveObserver(this);
   model_ = NULL;
 }
 
-void BookmarkBarView::BookmarkNodeMoved(BookmarkBarModel* model,
-                                        BookmarkBarNode* old_parent,
+void BookmarkBarView::BookmarkNodeMoved(BookmarkModel* model,
+                                        BookmarkNode* old_parent,
                                         int old_index,
-                                        BookmarkBarNode* new_parent,
+                                        BookmarkNode* new_parent,
                                         int new_index) {
   StopThrobbing(true);
   BookmarkNodeRemovedImpl(model, old_parent, old_index);
   BookmarkNodeAddedImpl(model, new_parent, new_index);
   StartThrobbing();
 }
 
-void BookmarkBarView::BookmarkNodeAdded(BookmarkBarModel* model,
-                                        BookmarkBarNode* parent,
+void BookmarkBarView::BookmarkNodeAdded(BookmarkModel* model,
+                                        BookmarkNode* parent,
                                         int index) {
   StopThrobbing(true);
   BookmarkNodeAddedImpl(model, parent, index);
   StartThrobbing();
 }
 
-void BookmarkBarView::BookmarkNodeAddedImpl(BookmarkBarModel* model,
-                                            BookmarkBarNode* parent,
+void BookmarkBarView::BookmarkNodeAddedImpl(BookmarkModel* model,
+                                            BookmarkNode* parent,
                                             int index) {
   NotifyModelChanged();
   if (parent != model_->GetBookmarkBarNode()) {
     // We only care about nodes on the bookmark bar.
     return;
   }
   DCHECK(index >= 0 && index <= GetBookmarkButtonCount());
   AddChildView(index, CreateBookmarkButton(parent->GetChild(index)));
   Layout();
   SchedulePaint();
 }
 
-void BookmarkBarView::BookmarkNodeRemoved(BookmarkBarModel* model,
-                                          BookmarkBarNode* parent,
+void BookmarkBarView::BookmarkNodeRemoved(BookmarkModel* model,
+                                          BookmarkNode* parent,
                                           int index) {
   StopThrobbing(true);
   BookmarkNodeRemovedImpl(model, parent, index);
   StartThrobbing();
 }
 
-void BookmarkBarView::BookmarkNodeRemovedImpl(BookmarkBarModel* model,
-                                              BookmarkBarNode* parent,
+void BookmarkBarView::BookmarkNodeRemovedImpl(BookmarkModel* model,
+                                              BookmarkNode* parent,
                                               int index) {
   NotifyModelChanged();
   if (parent != model_->GetBookmarkBarNode()) {
     // We only care about nodes on the bookmark bar.
     return;
   }
   DCHECK(index >= 0 && index < GetBookmarkButtonCount());
   ChromeViews::View* button = GetChildViewAt(index);
   RemoveChildView(button);
   MessageLoop::current()->DeleteSoon(FROM_HERE, button);
   Layout();
   SchedulePaint();
 }
 
-void BookmarkBarView::BookmarkNodeChanged(BookmarkBarModel* model,
-                                          BookmarkBarNode* node) {
+void BookmarkBarView::BookmarkNodeChanged(BookmarkModel* model,
+                                          BookmarkNode* node) {
   NotifyModelChanged();
   BookmarkNodeChangedImpl(model, node);
 }
 
-void BookmarkBarView::BookmarkNodeChangedImpl(BookmarkBarModel* model,
-                                              BookmarkBarNode* node) {
+void BookmarkBarView::BookmarkNodeChangedImpl(BookmarkModel* model,
+                                              BookmarkNode* node) {
   if (node->GetParent() != model_->GetBookmarkBarNode()) {
     // We only care about nodes on the bookmark bar.
     return;
   }
   int index = model_->GetBookmarkBarNode()->IndexOfChild(node);
   DCHECK(index != -1);
   ChromeViews::TextButton* button = GetBookmarkButton(index);
   CSize old_pref;
   button->GetPreferredSize(&old_pref);
   ConfigureButton(node, button);
   CSize new_pref;
   button->GetPreferredSize(&new_pref);
   if (old_pref.cx != new_pref.cx) {
     Layout();
     SchedulePaint();
   } else if (button->IsVisible()) {
     button->SchedulePaint();
   }
 }
 
-void BookmarkBarView::BookmarkNodeFavIconLoaded(BookmarkBarModel* model,
-                                                BookmarkBarNode* node) {
+void BookmarkBarView::BookmarkNodeFavIconLoaded(BookmarkModel* model,
+                                                BookmarkNode* node) {
   if (menu_runner_.get())
     menu_runner_->FavIconLoaded(node);
   if (drop_menu_runner_.get())
     drop_menu_runner_->FavIconLoaded(node);
   BookmarkNodeChangedImpl(model, node);
 }
 
 void BookmarkBarView::WriteDragData(View* sender,
                                     int press_x,
                                     int press_y,
                                     OSExchangeData* data) {
   UserMetrics::RecordAction(L"BookmarkBar_DragButton", profile_);
 
   for (int i = 0; i < GetBookmarkButtonCount(); ++i) {
     if (sender == GetBookmarkButton(i)) {
       ChromeViews::TextButton* button = GetBookmarkButton(i);
       ChromeCanvas canvas(button->GetWidth(), button->GetHeight(), false);
       button->Paint(&canvas, true);
       drag_utils::SetDragImageOnDataObject(canvas, button->GetWidth(),
                                            button->GetHeight(), press_x,
                                            press_y, data);
       WriteDragData(model_->GetBookmarkBarNode()->GetChild(i), data);
       return;
     }
   }
   NOTREACHED();
 }
 
-void BookmarkBarView::WriteDragData(BookmarkBarNode* node,
+void BookmarkBarView::WriteDragData(BookmarkNode* node,
                                     OSExchangeData* data) {
   DCHECK(node && data);
   BookmarkDragData drag_data(node);
   drag_data.profile_id = GetProfile()->GetID();
   drag_data.Write(data);
 }
 
 int BookmarkBarView::GetDragOperations(View* sender, int x, int y) {
   for (int i = 0; i < GetBookmarkButtonCount(); ++i) {
     if (sender == GetBookmarkButton(i)) {
       return GetDragOperationsForNode(
           model_->GetBookmarkBarNode()->GetChild(i));
     }
   }
   NOTREACHED();
   return DragDropTypes::DRAG_NONE;
 }
 
 void BookmarkBarView::RunMenu(ChromeViews::View* view,
                               const CPoint& pt,
                               HWND hwnd) {
-  BookmarkBarNode* node;
+  BookmarkNode* node;
   MenuItemView::AnchorPosition anchor_point = MenuItemView::TOPLEFT;
 
   // When we set the menu's position, we must take into account the mirrored
   // position of the View relative to its parent. This can be easily done by
   // passing the right flag to View::GetX().
   int x = view->GetX(APPLY_MIRRORING_TRANSFORMATION);
   int height = GetHeight() - kMenuOffset;
 
   if (IsNewTabPage() && !IsAlwaysShown())
     height -= kNewtabVerticalPadding;
@@ skipping 34 matching lines @@
   menu_runner_->RunMenuAt(parent_hwnd,
                           gfx::Rect(screen_loc.x, screen_loc.y,
                                     view->GetWidth(), height),
                           anchor_point,
                           false);
 }
 
 void BookmarkBarView::ButtonPressed(ChromeViews::BaseButton* sender) {
   int index = GetChildIndex(sender);
   DCHECK(index != -1);
-  BookmarkBarNode* node = model_->GetBookmarkBarNode()->GetChild(index);
+  BookmarkNode* node = model_->GetBookmarkBarNode()->GetChild(index);
   DCHECK(page_navigator_);
   page_navigator_->OpenURL(
       node->GetURL(),
       event_utils::DispositionFromEventFlags(sender->mouse_event_flags()),
       PageTransition::AUTO_BOOKMARK);
   UserMetrics::RecordAction(L"ClickedBookmarkBarURLButton", profile_);
 }
 
 void BookmarkBarView::ShowContextMenu(View* source,
                                       int x,
                                       int y,
                                       bool is_mouse_gesture) {
   if (!model_->IsLoaded()) {
     // Don't do anything if the model isn't loaded.
     return;
   }
 
-  BookmarkBarNode* node = model_->GetBookmarkBarNode();
+  BookmarkNode* node = model_->GetBookmarkBarNode();
   if (source == other_bookmarked_button_) {
     node = model_->other_node();
   } else if (source != this) {
     // User clicked on one of the bookmark buttons, find which one they
     // clicked on.
     int bookmark_button_index = GetChildIndex(source);
     DCHECK(bookmark_button_index != -1 &&
            bookmark_button_index < GetBookmarkButtonCount());
     node = model_->GetBookmarkBarNode()->GetChild(bookmark_button_index);
   }
   BookmarkBarContextMenuController controller(this, node);
   controller.RunMenuAt(x, y);
 }
 
-ChromeViews::View* BookmarkBarView::CreateBookmarkButton(
-    BookmarkBarNode* node) {
+ChromeViews::View* BookmarkBarView::CreateBookmarkButton(BookmarkNode* node) {
   if (node->GetType() == history::StarredEntry::URL) {
     BookmarkButton* button = new BookmarkButton(node->GetURL(),
                                                 node->GetTitle(),
                                                 GetProfile());
     button->SetListener(this, 0);
     ConfigureButton(node, button);
     return button;
   } else {
     ChromeViews::MenuButton* button =
         new ChromeViews::MenuButton(node->GetTitle(), this, false);
     button->SetIcon(GetGroupIcon());
     ConfigureButton(node, button);
     return button;
   }
 }
 
-void BookmarkBarView::ConfigureButton(BookmarkBarNode* node,
+void BookmarkBarView::ConfigureButton(BookmarkNode* node,
                                       ChromeViews::TextButton* button) {
   button->SetText(node->GetTitle());
   button->ClearMaxTextSize();
   button->SetContextMenuController(this);
   button->SetDragController(this);
   if (node->GetType() == history::StarredEntry::URL) {
     if (node->GetFavIcon().width() != 0)
       button->SetIcon(node->GetFavIcon());
     else
       button->SetIcon(*kDefaultFavIcon);
@@ skipping 43 matching lines @@
   ns->RemoveObserver(this, NOTIFY_BOOKMARK_BUBBLE_HIDDEN, ns_source);
   ns->RemoveObserver(this, NOTIFY_BOOKMARK_BAR_VISIBILITY_PREF_CHANGED,
                      NotificationService::AllSources());
 }
 
 void BookmarkBarView::NotifyModelChanged() {
   if (model_changed_listener_)
     model_changed_listener_->ModelChanged();
 }
 
-void BookmarkBarView::ShowDropFolderForNode(BookmarkBarNode* node) {
+void BookmarkBarView::ShowDropFolderForNode(BookmarkNode* node) {
   if (drop_menu_runner_.get() && drop_menu_runner_->GetNode() == node) {
     // Already showing for the specified node.
     return;
   }
 
   int start_index = 0;
   View* view_to_position_menu_from;
 
   // Note that both the anchor position and the position of the menu itself
   // change depending on the locale. Also note that we must apply the
@@ skipping 37 matching lines @@
                 view_to_position_menu_from->GetWidth(),
                 view_to_position_menu_from->GetHeight()),
       anchor, true);
 }
 
 void BookmarkBarView::StopShowFolderDropMenuTimer() {
   if (show_folder_drop_menu_task_)
     show_folder_drop_menu_task_->Cancel();
 }
 
-void BookmarkBarView::StartShowFolderDropMenuTimer(BookmarkBarNode* node) {
+void BookmarkBarView::StartShowFolderDropMenuTimer(BookmarkNode* node) {
   if (testing_) {
     // So that tests can run as fast as possible disable the delay during
     // testing.
     ShowDropFolderForNode(node);
     return;
   }
   DCHECK(!show_folder_drop_menu_task_);
   show_folder_drop_menu_task_ = new ShowFolderDropMenuTask(this, node);
   static DWORD delay = 0;
   if (!delay && !SystemParametersInfo(SPI_GETMENUSHOWDELAY, 0, &delay, 0)) {
@@ skipping 45 matching lines @@
     return DragDropTypes::DRAG_COPY;
   }
 
   for (int i = 0; i < GetBookmarkButtonCount() &&
        GetBookmarkButton(i)->IsVisible() && !found; i++) {
     ChromeViews::TextButton* button = GetBookmarkButton(i);
     int button_x = mirrored_x - button->GetX();
     int button_w = button->GetWidth();
     if (button_x < button_w) {
       found = true;
-      BookmarkBarNode* node = model_->GetBookmarkBarNode()->GetChild(i);
+      BookmarkNode* node = model_->GetBookmarkBarNode()->GetChild(i);
       if (node->GetType() != history::StarredEntry::URL) {
         if (button_x <= MenuItemView::kDropBetweenPixels) {
           *index = i;
         } else if (button_x < button_w - MenuItemView::kDropBetweenPixels) {
           *index = i;
           *drop_on = true;
         } else {
           *index = i + 1;
         }
       } else if (button_x < button_w / 2) {
@@ skipping 24 matching lines @@
     } else if (mirrored_x < other_bookmarked_button_->GetX()) {
       // Mouse is after the last visible button but before more recently
       // bookmarked; use the last visible index.
       *index = GetFirstHiddenNodeIndex();
     } else {
       return DragDropTypes::DRAG_NONE;
     }
   }
 
   if (*drop_on) {
-    BookmarkBarNode* parent =
+    BookmarkNode* parent =
         *is_over_other ? model_->other_node() :
                          model_->GetBookmarkBarNode()->GetChild(*index);
     int operation =
         CalculateDropOperation(data, parent, parent->GetChildCount());
     if (!operation && !data.is_url &&
         data.profile_id == GetProfile()->GetID()) {
       if (data.GetNode(model_) == parent) {
         // Don't open a menu if the node being dragged is the the menu to
         // open.
         *drop_on = false;
       }
     }
     return operation;
   } else {
     return CalculateDropOperation(data, model_->GetBookmarkBarNode(), *index);
   }
 }
 
 int BookmarkBarView::CalculateDropOperation(const BookmarkDragData& data,
-                                            BookmarkBarNode* parent,
+                                            BookmarkNode* parent,
                                             int index) {
   if (!CanDropAt(data, parent, index))
     return DragDropTypes::DRAG_NONE;
 
   if (data.is_url) {
     // User is dragging a URL.
-    BookmarkBarNode* node = model_->GetNodeByURL(data.url);
+    BookmarkNode* node = model_->GetNodeByURL(data.url);
     if (!node) {
       // We don't have a node with this url.
       return DragDropTypes::DRAG_COPY;
     }
     // Technically we're going to move, but most sources export as copy so that
     // if we don't accept copy we won't accept the drop.
     return DragDropTypes::DRAG_MOVE | DragDropTypes::DRAG_COPY;
   } else if (data.profile_id == GetProfile()->GetID()) {
     // Dropping a group from the same profile results in a move.
-    BookmarkBarNode* node = data.GetNode(model_);
+    BookmarkNode* node = data.GetNode(model_);
     if (!node) {
       // Generally shouldn't get here, we originated the drag but couldn't
       // find the node.
       return DragDropTypes::DRAG_NONE;
     }
     return DragDropTypes::DRAG_MOVE;
   } else {
     // Dropping a group from different profile. Always accept.
     return DragDropTypes::DRAG_COPY;
   }
 }
 
 bool BookmarkBarView::CanDropAt(const BookmarkDragData& data,
-                                BookmarkBarNode* parent,
+                                BookmarkNode* parent,
                                 int index) {
   DCHECK(data.is_valid);
   if (data.is_url) {
-    BookmarkBarNode* existing_node = model_->GetNodeByURL(data.url);
+    BookmarkNode* existing_node = model_->GetNodeByURL(data.url);
     if (existing_node && existing_node->GetParent() == parent) {
       const int existing_index = parent->IndexOfChild(existing_node);
       if (index == existing_index || existing_index + 1 == index)
         return false;
     }
     return true;
   } else if (data.profile_id == profile_->GetID()) {
-    BookmarkBarNode* existing_node = data.GetNode(model_);
+    BookmarkNode* existing_node = data.GetNode(model_);
     if (existing_node) {
       if (existing_node->GetParent() == parent) {
         const int existing_index = parent->IndexOfChild(existing_node);
         if (index == existing_index || existing_index + 1 == index)
           return false;
       }
       // Allow the drop only if the node we're going to drop on isn't a
       // descendant of the dragged node.
-      BookmarkBarNode* test_node = parent;
+      BookmarkNode* test_node = parent;
       while (test_node && test_node != existing_node)
         test_node = test_node->GetParent();
       return (test_node == NULL);
     }
   }  // else case clones, always allow.
   return true;
 }
 
 
 int BookmarkBarView::PerformDropImpl(const BookmarkDragData& data,
-                                     BookmarkBarNode* parent_node,
+                                     BookmarkNode* parent_node,
                                      int index) {
   if (data.is_url) {
     // User is dragging a URL.
-    BookmarkBarNode* node = model_->GetNodeByURL(data.url);
+    BookmarkNode* node = model_->GetNodeByURL(data.url);
     if (!node) {
       std::wstring title = data.title;
       if (title.empty()) {
         // No title, use the host.
         title = UTF8ToWide(data.url.host());
         if (title.empty())
           title = l10n_util::GetString(IDS_BOOMARK_BAR_UNKNOWN_DRAG_TITLE);
       }
       model_->AddURL(parent_node, index, title, data.url);
       return DragDropTypes::DRAG_COPY;
     }
     model_->Move(node, parent_node, index);
     return DragDropTypes::DRAG_MOVE;
   } else if (data.profile_id == GetProfile()->GetID()) {
-    BookmarkBarNode* node = data.GetNode(model_);
+    BookmarkNode* node = data.GetNode(model_);
     if (!node) {
       // Generally shouldn't get here, we originated the drag but couldn't
       // find the node. Do nothing.
       return DragDropTypes::DRAG_COPY;
     }
     model_->Move(node, parent_node, index);
     return DragDropTypes::DRAG_MOVE;
   } else {
     // Dropping a group from different profile. Always accept.
     CloneDragData(data, parent_node, index);
     return DragDropTypes::DRAG_COPY;
   }
 }
 
 void BookmarkBarView::CloneDragData(const BookmarkDragData& data,
-                                    BookmarkBarNode* parent,
+                                    BookmarkNode* parent,
                                     int index_to_add_at) {
   DCHECK(data.is_valid && model_);
   if (data.is_url) {
-    BookmarkBarNode* node = model_->GetNodeByURL(data.url);
+    BookmarkNode* node = model_->GetNodeByURL(data.url);
     if (node) {
       model_->Move(node, parent, index_to_add_at);
     } else {
       model_->AddURL(parent, index_to_add_at, data.title, data.url);
     }
   } else {
-    BookmarkBarNode* new_folder = model_->AddGroup(parent, index_to_add_at,
-                                                   data.title);
+    BookmarkNode* new_folder = model_->AddGroup(parent, index_to_add_at,
+                                                data.title);
     for (int i = 0; i < static_cast<int>(data.children.size()); ++i)
       CloneDragData(data.children[i], new_folder, i);
   }
 }
 
 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() {
   DCHECK(!throbbing_view_);
 
   if (bubble_url_.is_empty())
     return;  // Bubble isn't showing; nothing to throb.
 
   if (!GetViewContainer())
     return;  // We're not showing, don't do anything.
 
-  BookmarkBarNode* node = model_->GetNodeByURL(bubble_url_);
+  BookmarkNode* node = model_->GetNodeByURL(bubble_url_);
   if (!node)
     return;  // Generally shouldn't happen.
 
   // Determine which visible button is showing the url (or is an ancestor of
   // the url).
   if (node->HasAncestor(model_->GetBookmarkBarNode())) {
-    BookmarkBarNode* bbn = model_->GetBookmarkBarNode();
-    BookmarkBarNode* parent_on_bb = node;
+    BookmarkNode* bbn = model_->GetBookmarkBarNode();
+    BookmarkNode* parent_on_bb = node;
     while (parent_on_bb->GetParent() != bbn)
       parent_on_bb = parent_on_bb->GetParent();
     int index = bbn->IndexOfChild(parent_on_bb);
     if (index >= GetFirstHiddenNodeIndex()) {
       // Node is hidden, animate the overflow button.
       throbbing_view_ = overflow_button_;
     } else {
       throbbing_view_ = static_cast<BaseButton*>(GetChildViewAt(index));
     }
   } else {
     throbbing_view_ = other_bookmarked_button_;
   }
 
   // Use a large number so that the button continues to throb.
   throbbing_view_->StartThrobbing(std::numeric_limits<int>::max());
 }
 
 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;
 }