Renames BoomarkBarModel to BookmarkModel.

chrome/browser/views/bookmark_editor_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_editor_view.h"
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "chrome/app/locales/locale_settings.h"
@@ skipping 131 matching lines @@
   }
 }
 
 void BookmarkEditorView::OnTreeViewSelectionChanged(
     ChromeViews::TreeView* tree_view) {
 }
 
 bool BookmarkEditorView::CanEdit(ChromeViews::TreeView* tree_view,
                                  ChromeViews::TreeModelNode* node) {
   // Only allow editting of children of the bookmark bar node and other node.
-  BookmarkNode* bb_node = tree_model_->AsNode(node);
+  EditorNode* bb_node = tree_model_->AsNode(node);
   return (bb_node->GetParent() && bb_node->GetParent()->GetParent());
 }
 
 void BookmarkEditorView::ContentsChanged(TextField* sender,
                                          const std::wstring& new_contents) {
   UserInputChanged();
 }
 
 void BookmarkEditorView::ButtonPressed(NativeButton* sender) {
   DCHECK(sender);
@@ skipping 53 matching lines @@
   context_menu_->AppendMenuItemWithLabel(IDS_EDIT,
       l10n_util::GetString(IDS_EDIT));
   context_menu_->AppendMenuItemWithLabel(
       IDS_BOOMARK_EDITOR_NEW_FOLDER_MENU_ITEM,
       l10n_util::GetString(IDS_BOOMARK_EDITOR_NEW_FOLDER_MENU_ITEM));
   context_menu_->RunMenuAt(x, y);
 }
 
 void BookmarkEditorView::Init() {
   tree_view_.SetContextMenuController(this);
-  bb_model_ = profile_->GetBookmarkBarModel();
+  bb_model_ = profile_->GetBookmarkModel();
   DCHECK(bb_model_);
   bb_model_->AddObserver(this);
 
   tree_view_.SetRootShown(false);
   // Tell View not to delete all Views declared by value.
   tree_view_.SetParentOwned(false);
   new_group_button_.SetParentOwned(false);
   url_tf_.SetParentOwned(false);
   title_tf_.SetParentOwned(false);
 
@@ skipping 51 matching lines @@
 
   layout->StartRow(1, single_column_view_set_id);
   layout->AddView(&tree_view_);
 
   layout->AddPaddingRow(0, kRelatedControlVerticalSpacing);
 
   if (bb_model_->IsLoaded())
     Loaded(bb_model_);
 }
 
-void BookmarkEditorView::Loaded(BookmarkBarModel* model) {
+void BookmarkEditorView::Loaded(BookmarkModel* model) {
   Reset(true);
 }
 
-void BookmarkEditorView::BookmarkNodeMoved(BookmarkBarModel* model,
-                                 BookmarkBarNode* old_parent,
-                                 int old_index,
-                                 BookmarkBarNode* new_parent,
-                                 int new_index) {
+void BookmarkEditorView::BookmarkNodeMoved(BookmarkModel* model,
+                                           BookmarkNode* old_parent,
+                                           int old_index,
+                                           BookmarkNode* new_parent,
+                                           int new_index) {
   Reset(false);
 }
 
-void BookmarkEditorView::BookmarkNodeAdded(BookmarkBarModel* model,
-                                           BookmarkBarNode* parent,
+void BookmarkEditorView::BookmarkNodeAdded(BookmarkModel* model,
+                                           BookmarkNode* parent,
                                            int index) {
   Reset(false);
 }
 
-void BookmarkEditorView::BookmarkNodeRemoved(BookmarkBarModel* model,
-                                             BookmarkBarNode* parent,
+void BookmarkEditorView::BookmarkNodeRemoved(BookmarkModel* model,
+                                             BookmarkNode* parent,
                                              int index) {
   Reset(false);
 }
 
 void BookmarkEditorView::Reset(bool first_time) {
-  BookmarkBarNode* node_editing = bb_model_->GetNodeByURL(url_);
+  BookmarkNode* node_editing = bb_model_->GetNodeByURL(url_);
 
   // If the title is empty we need to fetch it from the node.
   if (first_time && title_.empty()) {
     if (node_editing) {
       title_ = node_editing->GetTitle();
       title_tf_.SetText(title_);
     }
   }
 
   // Do this first, otherwise when we invoke SetModel with the real one
   // tree_view will try to invoke something on the model we just deleted.
   tree_view_.SetModel(NULL);
 
-  BookmarkNode* root_node = CreateRootNode();
-  tree_model_.reset(new BookmarkTreeModel(root_node));
+  EditorNode* root_node = CreateRootNode();
+  tree_model_.reset(new EditorTreeModel(root_node));
 
   tree_view_.SetModel(tree_model_.get());
   tree_view_.SetController(this);
 
   new_group_button_.SetEnabled(true);
 
   context_menu_.reset();
 
   if (GetParent()) {
     ExpandAndSelect();
@@ skipping 18 matching lines @@
   if (!url.is_valid())
     url_tf_.SetBackgroundColor(kErrorColor);
   else
     url_tf_.SetDefaultBackgroundColor();
   GetDialogClientView()->UpdateDialogButtons();
 }
 
 void BookmarkEditorView::NewGroup() {
   // Create a new entry parented to the selected item, or the bookmark
   // bar if nothing is selected.
-  BookmarkNode* parent = tree_model_->AsNode(tree_view_.GetSelectedNode());
+  EditorNode* parent = tree_model_->AsNode(tree_view_.GetSelectedNode());
   if (!parent) {
     NOTREACHED();
     return;
   }
 
   tree_view_.StartEditing(AddNewGroup(parent));
 }
 
-BookmarkEditorView::BookmarkNode* BookmarkEditorView::AddNewGroup(
-    BookmarkNode* parent) {
-  BookmarkNode* new_node = new BookmarkNode();
+BookmarkEditorView::EditorNode* BookmarkEditorView::AddNewGroup(
+    EditorNode* parent) {
+  EditorNode* new_node = new EditorNode();
   new_node->SetTitle(l10n_util::GetString(IDS_BOOMARK_EDITOR_NEW_FOLDER_NAME));
   new_node->value = 0;
   // new_node is now owned by parent.
   tree_model_->Add(parent, parent->GetChildCount(), new_node);
   return new_node;
 }
 
 void BookmarkEditorView::ExpandAndSelect() {
   tree_view_.ExpandAll();
 
-  BookmarkBarNode* to_select = bb_model_->GetNodeByURL(url_);
+  BookmarkNode* to_select = bb_model_->GetNodeByURL(url_);
   int group_id_to_select =
       to_select ? to_select->GetParent()->id() :
                   bb_model_->GetParentForNewNodes()->id();
 
   DCHECK(group_id_to_select);  // GetMostRecentParent should never return NULL.
-  BookmarkNode* b_node =
+  EditorNode* b_node =
       FindNodeWithID(tree_model_->GetRoot(), group_id_to_select);
   if (!b_node)
     b_node = tree_model_->GetRoot()->GetChild(0);  // Bookmark bar node.
 
   tree_view_.SetSelectedNode(b_node);
 }
 
-BookmarkEditorView::BookmarkNode* BookmarkEditorView::CreateRootNode() {
-  BookmarkNode* root_node = new BookmarkNode(std::wstring(), 0);
-  BookmarkBarNode* bb_root_node = bb_model_->root_node();
+BookmarkEditorView::EditorNode* BookmarkEditorView::CreateRootNode() {
+  EditorNode* root_node = new EditorNode(std::wstring(), 0);
+  BookmarkNode* bb_root_node = bb_model_->root_node();
   CreateNodes(bb_root_node, root_node);
   DCHECK(root_node->GetChildCount() == 2);
   DCHECK(bb_root_node->GetChild(0)->GetType() ==
          history::StarredEntry::BOOKMARK_BAR);
   DCHECK(bb_root_node->GetChild(1)->GetType() == history::StarredEntry::OTHER);
   return root_node;
 }
 
-void BookmarkEditorView::CreateNodes(BookmarkBarNode* bb_node,
-                                     BookmarkEditorView::BookmarkNode* b_node) {
+void BookmarkEditorView::CreateNodes(BookmarkNode* bb_node,
+                                     BookmarkEditorView::EditorNode* b_node) {
   for (int i = 0; i < bb_node->GetChildCount(); ++i) {
-    BookmarkBarNode* child_bb_node = bb_node->GetChild(i);
+    BookmarkNode* child_bb_node = bb_node->GetChild(i);
     if (child_bb_node->is_folder()) {
-      BookmarkNode* new_b_node = new BookmarkNode(child_bb_node->GetTitle(),
+      EditorNode* new_b_node = new EditorNode(child_bb_node->GetTitle(),
                                                   child_bb_node->id());
       b_node->Add(b_node->GetChildCount(), new_b_node);
       CreateNodes(child_bb_node, new_b_node);
     }
   }
 }
 
-BookmarkEditorView::BookmarkNode* BookmarkEditorView::FindNodeWithID(
-    BookmarkEditorView::BookmarkNode* node,
+BookmarkEditorView::EditorNode* BookmarkEditorView::FindNodeWithID(
+    BookmarkEditorView::EditorNode* node,
     int id) {
   if (node->value == id)
     return node;
   for (int i = 0; i < node->GetChildCount(); ++i) {
-    BookmarkNode* result = FindNodeWithID(node->GetChild(i), id);
+    EditorNode* result = FindNodeWithID(node->GetChild(i), id);
     if (result)
       return result;
   }
   return NULL;
 }
 
 void BookmarkEditorView::ApplyEdits() {
   DCHECK(bb_model_->IsLoaded());
 
   if (!tree_view_.GetSelectedNode()) {
     NOTREACHED();
     return;
   }
   ApplyEdits(tree_model_->AsNode(tree_view_.GetSelectedNode()));
 }
 
-void BookmarkEditorView::ApplyEdits(BookmarkNode* parent) {
+void BookmarkEditorView::ApplyEdits(EditorNode* parent) {
   DCHECK(parent);
 
   // We're going to apply edits to the bookmark bar model, which will call us
   // back. Normally when a structural edit occurs we reset the tree model.
   // We don't want to do that here, so we remove ourselves as an observer.
   bb_model_->RemoveObserver(this);
 
   GURL new_url(GetInputURL());
   std::wstring new_title(GetInputTitle());
 
-  BookmarkBarNode* old_node = bb_model_->GetNodeByURL(url_);
-  BookmarkBarNode* old_parent = old_node ? old_node->GetParent() : NULL;
+  BookmarkNode* old_node = bb_model_->GetNodeByURL(url_);
+  BookmarkNode* old_parent = old_node ? old_node->GetParent() : NULL;
   const int old_index = old_parent ? old_parent->IndexOfChild(old_node) : -1;
 
   if (url_ != new_url) {
     // The URL has changed, unstar the old url.
     bb_model_->SetURLStarred(url_, std::wstring(), false);
   }
 
   // Create the new groups and update the titles.
-  BookmarkBarNode* new_parent = NULL;
+  BookmarkNode* new_parent = NULL;
   ApplyNameChangesAndCreateNewGroups(
       bb_model_->root_node(), tree_model_->GetRoot(), parent, &new_parent);
 
   if (!new_parent) {
     // Bookmarks must be parented.
     NOTREACHED();
     return;
   }
 
-  BookmarkBarNode* current_node = bb_model_->GetNodeByURL(new_url);
+  BookmarkNode* current_node = bb_model_->GetNodeByURL(new_url);
 
   if (current_node) {
     // There's already a node with the URL.
     bb_model_->SetTitle(current_node, new_title);
     if (new_parent == old_parent) {
       // Parent hasn't changed.
       bb_model_->Move(current_node, new_parent, old_index);
     } else {
       // Parent changed, move to end of new parent.
       bb_model_->Move(current_node, new_parent, new_parent->GetChildCount());
     }
   } else {
     // Adding a new URL.
     if (new_parent == old_parent) {
       // Parent hasn't changed. Place newly created bookmark at the same
       // location as last bookmark.
       bb_model_->AddURL(new_parent, old_index, new_title, new_url);
     } else {
       // Parent changed, put bookmark at end of new parent.
       bb_model_->AddURL(new_parent, new_parent->GetChildCount(), new_title,
                         new_url);
     }
   }
 }
 
 void BookmarkEditorView::ApplyNameChangesAndCreateNewGroups(
-    BookmarkBarNode* bb_node,
-    BookmarkEditorView::BookmarkNode* b_node,
-    BookmarkEditorView::BookmarkNode* parent_b_node,
-    BookmarkBarNode** parent_bb_node) {
+    BookmarkNode* bb_node,
+    BookmarkEditorView::EditorNode* b_node,
+    BookmarkEditorView::EditorNode* parent_b_node,
+    BookmarkNode** parent_bb_node) {
   if (parent_b_node == b_node)
     *parent_bb_node = bb_node;
   for (int i = 0; i < b_node->GetChildCount(); ++i) {
-    BookmarkNode* child_b_node = b_node->GetChild(i);
-    BookmarkBarNode* child_bb_node = NULL;
+    EditorNode* child_b_node = b_node->GetChild(i);
+    BookmarkNode* child_bb_node = NULL;
     if (child_b_node->value == 0) {
       // New group.
       child_bb_node = bb_model_->AddGroup(bb_node,
           bb_node->GetChildCount(), child_b_node->GetTitle());
     } else {
       // Existing node, reset the title (BBModel ignores changes if the title
       // is the same).
       for (int j = 0; j < bb_node->GetChildCount(); ++j) {
-        BookmarkBarNode* node = bb_node->GetChild(j);
+        BookmarkNode* node = bb_node->GetChild(j);
         if (node->is_folder() && node->id() == child_b_node->value) {
           child_bb_node = node;
           break;
         }
       }
       DCHECK(child_bb_node);
       bb_model_->SetTitle(child_bb_node, child_b_node->GetTitle());
     }
     ApplyNameChangesAndCreateNewGroups(child_bb_node, child_b_node,
                                        parent_b_node, parent_bb_node);
   }
 }