Eliminate Bookmarks dependence to bookmark_undo_utils.h.

chrome/browser/bookmarks/bookmark_utils.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/bookmarks/bookmark_utils.h"
 
 #include <utility>
 
 #include "base/basictypes.h"
 #include "base/files/file_path.h"
 #include "base/i18n/case_conversion.h"
 #include "base/i18n/string_search.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
+#include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "chrome/browser/history/query_parser.h"
-#include "chrome/browser/undo/bookmark_undo_service.h"
-#include "chrome/browser/undo/bookmark_undo_service_factory.h"
-#include "chrome/browser/undo/bookmark_undo_utils.h"
 #include "chrome/common/pref_names.h"
 #include "components/user_prefs/pref_registry_syncable.h"
 #include "content/public/browser/user_metrics.h"
 #include "net/base/net_util.h"
 #include "ui/base/models/tree_node_iterator.h"
 
 using base::Time;
 
 namespace {
 
@@ skipping 109 matching lines @@
   // Create array of selected nodes with descendants filtered out.
   std::vector<const BookmarkNode*> filteredNodes;
   for (size_t i = 0; i < nodes.size(); ++i)
     if (!HasSelectedAncestor(model, nodes, nodes[i]->parent()))
       filteredNodes.push_back(nodes[i]);
 
   BookmarkNodeData(filteredNodes).
       WriteToClipboard(ui::CLIPBOARD_TYPE_COPY_PASTE);
 
   if (remove_nodes) {
-#if !defined(OS_ANDROID)
-    ScopedGroupBookmarkActions group_cut(model->profile());
-#endif
+    ScopedGroupBookmarkActions grouped_cut(model);
     for (size_t i = 0; i < filteredNodes.size(); ++i) {
       int index = filteredNodes[i]->parent()->GetIndexOf(filteredNodes[i]);
       if (index > -1)
         model->Remove(filteredNodes[i]->parent(), index);
     }
   }
 }
 
 void PasteFromClipboard(BookmarkModel* model,
                         const BookmarkNode* parent,
                         int index) {
   if (!parent)
     return;
 
   BookmarkNodeData bookmark_data;
   if (!bookmark_data.ReadFromClipboard(ui::CLIPBOARD_TYPE_COPY_PASTE))
     return;
 
   if (index == -1)
     index = parent->child_count();
-#if !defined(OS_ANDROID)
-  ScopedGroupBookmarkActions group_paste(model->profile());
-#endif
+  ScopedGroupBookmarkActions grouped_paste(model);
   CloneBookmarkNode(model, bookmark_data.elements, parent, index, true);
 }
 
 bool CanPasteFromClipboard(const BookmarkNode* node) {
   if (!node)
     return false;
   return BookmarkNodeData::ClipboardContainsBookmarks();
 }
 
 std::vector<const BookmarkNode*> GetMostRecentlyModifiedFolders(
@@ skipping 179 matching lines @@
 
   // Remove all the bookmarks.
   for (size_t i = 0; i < bookmarks.size(); ++i) {
     const BookmarkNode* node = bookmarks[i];
     int index = node->parent()->GetIndexOf(node);
     if (index > -1)
       model->Remove(node->parent(), index);
   }
 }
 
+// ScopedGroupBookmarkActions -------------------------------------------------
+
+ScopedGroupBookmarkActions::ScopedGroupBookmarkActions(Profile* profile)
+    : model_(NULL) {
+  if (profile)
+    model_ = BookmarkModelFactory::GetForProfile(profile);
+  if (model_)
+    model_->BeginGroupedChanges();
+}
+
+ScopedGroupBookmarkActions::ScopedGroupBookmarkActions(BookmarkModel* model)
+    : model_(model) {
+  if (model_)
+    model_->BeginGroupedChanges();
+}
+
+ScopedGroupBookmarkActions::~ScopedGroupBookmarkActions() {
+  if (model_)
+    model_->EndGroupedChanges();
+}
+
 }  // namespace bookmark_utils