Extract GetNodeByID() method from BookmarkModel.

chrome/browser/undo/bookmark_undo_service.cc

 // Copyright 2013 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/undo/bookmark_undo_service.h"
 
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "chrome/browser/bookmarks/bookmark_node_data.h"
 #include "chrome/browser/bookmarks/bookmark_utils.h"
@@ skipping 63 matching lines @@
 BookmarkAddOperation::BookmarkAddOperation(Profile* profile,
                                            const BookmarkNode* parent,
                                            int index)
   : BookmarkUndoOperation(profile),
     parent_id_(parent->id()),
     index_(index) {
 }
 
 void BookmarkAddOperation::Undo() {
   BookmarkModel* model = GetBookmarkModel();
-  const BookmarkNode* parent = model->GetNodeByID(parent_id_);
+  const BookmarkNode* parent = bookmark_utils::GetNodeByID(model, parent_id_);
   DCHECK(parent);
 
   model->Remove(parent, index_);
 }
 
 int BookmarkAddOperation::GetUndoLabelId() const {
   return IDS_BOOKMARK_BAR_UNDO_ADD;
 }
 
 int BookmarkAddOperation::GetRedoLabelId() const {
@@ skipping 45 matching lines @@
                                                  const BookmarkNode* node)
   : BookmarkUndoOperation(profile),
     parent_id_(parent->id()),
     old_index_(old_index),
     removed_node_(node) {
 }
 
 void BookmarkRemoveOperation::Undo() {
   DCHECK(removed_node_.is_valid());
   BookmarkModel* model = GetBookmarkModel();
-  const BookmarkNode* parent = model->GetNodeByID(parent_id_);
+  const BookmarkNode* parent = bookmark_utils::GetNodeByID(model, parent_id_);
   DCHECK(parent);
 
   bookmark_utils::CloneBookmarkNode(model, removed_node_.elements, parent,
                                     old_index_, false);
   UpdateBookmarkIds(removed_node_.elements[0], parent, old_index_);
 }
 
 int BookmarkRemoveOperation::GetUndoLabelId() const {
   return IDS_BOOKMARK_BAR_UNDO_DELETE;
 }
@@ skipping 47 matching lines @@
 BookmarkEditOperation::BookmarkEditOperation(Profile* profile,
                                              const BookmarkNode* node)
     : BookmarkUndoOperation(profile),
       node_id_(node->id()),
       original_bookmark_(node) {
 }
 
 void BookmarkEditOperation::Undo() {
   DCHECK(original_bookmark_.is_valid());
   BookmarkModel* model = GetBookmarkModel();
-  const BookmarkNode* node = model->GetNodeByID(node_id_);
+  const BookmarkNode* node = bookmark_utils::GetNodeByID(model, node_id_);
   DCHECK(node);
 
   model->SetTitle(node, original_bookmark_.elements[0].title);
   if (original_bookmark_.elements[0].is_url)
     model->SetURL(node, original_bookmark_.elements[0].url);
 }
 
 int BookmarkEditOperation::GetUndoLabelId() const {
   return IDS_BOOKMARK_BAR_UNDO_EDIT;
 }
@@ skipping 43 matching lines @@
                                              int new_index)
     : BookmarkUndoOperation(profile),
       old_parent_id_(old_parent->id()),
       new_parent_id_(new_parent->id()),
       old_index_(old_index),
       new_index_(new_index) {
 }
 
 void BookmarkMoveOperation::Undo() {
   BookmarkModel* model = GetBookmarkModel();
-  const BookmarkNode* old_parent = model->GetNodeByID(old_parent_id_);
-  const BookmarkNode* new_parent = model->GetNodeByID(new_parent_id_);
+  const BookmarkNode* old_parent =
+      bookmark_utils::GetNodeByID(model, old_parent_id_);
+  const BookmarkNode* new_parent =
+      bookmark_utils::GetNodeByID(model, new_parent_id_);
   DCHECK(old_parent);
   DCHECK(new_parent);
 
   const BookmarkNode* node = new_parent->GetChild(new_index_);
   int destination_index = old_index_;
 
   // If the bookmark was moved up within the same parent then the destination
   // index needs to be incremented since the old index did not account for the
   // moved bookmark.
   if (old_parent == new_parent && new_index_ < old_index_)
@@ skipping 51 matching lines @@
   ordered_bookmarks_.resize(parent->child_count());
   for (int i = 0; i < parent->child_count(); ++i)
     ordered_bookmarks_[i] = parent->GetChild(i)->id();
 }
 
 BookmarkReorderOperation::~BookmarkReorderOperation() {
 }
 
 void BookmarkReorderOperation::Undo() {
   BookmarkModel* model = GetBookmarkModel();
-  const BookmarkNode* parent = model->GetNodeByID(parent_id_);
+  const BookmarkNode* parent = bookmark_utils::GetNodeByID(model, parent_id_);
   DCHECK(parent);
 
   std::vector<const BookmarkNode*> ordered_nodes;
-  for (size_t i = 0; i < ordered_bookmarks_.size(); ++i)
-    ordered_nodes.push_back(model->GetNodeByID(ordered_bookmarks_[i]));
+  for (size_t i = 0; i < ordered_bookmarks_.size(); ++i) {
+    ordered_nodes.push_back(
+        bookmark_utils::GetNodeByID(model, ordered_bookmarks_[i]));
+  }
 
   model->ReorderChildren(parent, ordered_nodes);
 }
 
 int BookmarkReorderOperation::GetUndoLabelId() const {
   return IDS_BOOKMARK_BAR_UNDO_REORDER;
 }
 
 int BookmarkReorderOperation::GetRedoLabelId() const {
   return IDS_BOOKMARK_BAR_REDO_REORDER;
@@ skipping 97 matching lines @@
 
 void BookmarkUndoService::OnBookmarkRenumbered(int64 old_id, int64 new_id) {
   std::vector<UndoOperation*> all_operations =
       undo_manager()->GetAllUndoOperations();
   for (std::vector<UndoOperation*>::iterator it = all_operations.begin();
        it != all_operations.end(); ++it) {
     static_cast<BookmarkUndoOperation*>(*it)->OnBookmarkRenumbered(old_id,
                                                                    new_id);
   }
 }