bookmarks: Simplify is_permanent_node() implementation.

chrome/browser/bookmarks/bookmark_model.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/bookmarks/bookmark_model.h"
 
 #include <algorithm>
 #include <functional>
 
 #include "base/callback.h"
@@ skipping 176 matching lines @@
   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
                     BookmarkImportBeginning(this));
 }
 
 void BookmarkModel::EndImportMode() {
   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
                     BookmarkImportEnding(this));
 }
 
 void BookmarkModel::Remove(const BookmarkNode* parent, int index) {
-  if (!loaded_ || !IsValidIndex(parent, index, false) || is_root(parent)) {
+  if (!loaded_ || !IsValidIndex(parent, index, false) ||
+      parent == root_node()) {
     NOTREACHED();
     return;
   }
   RemoveAndDeleteNode(AsMutable(parent->GetChild(index)));
 }
 
 void BookmarkModel::Move(const BookmarkNode* node,
                          const BookmarkNode* new_parent,
                          int index) {
   if (!loaded_ || !node || !IsValidIndex(new_parent, index, true) ||
-      is_root(new_parent) || is_permanent_node(node)) {
+      new_parent == root_node() || is_permanent_node(node)) {
     NOTREACHED();
     return;
   }
 
   if (new_parent->HasAncestor(node)) {
     // Can't make an ancestor of the node be a child of the node.
     NOTREACHED();
     return;
   }
 
@@ skipping 18 matching lines @@
 
   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
                     BookmarkNodeMoved(this, old_parent, old_index,
                                       new_parent, index));
 }
 
 void BookmarkModel::Copy(const BookmarkNode* node,
                          const BookmarkNode* new_parent,
                          int index) {
   if (!loaded_ || !node || !IsValidIndex(new_parent, index, true) ||
-      is_root(new_parent) || is_permanent_node(node)) {
+      new_parent == root_node() || is_permanent_node(node)) {
     NOTREACHED();
     return;
   }
 
   if (new_parent->HasAncestor(node)) {
     // Can't make an ancestor of the node be a child of the node.
     NOTREACHED();
     return;
   }
 
@@ skipping 135 matching lines @@
 }
 
 const BookmarkNode* BookmarkModel::GetNodeByID(int64 id) {
   // TODO(sky): TreeNode needs a method that visits all nodes using a predicate.
   return GetNodeByID(&root_, id);
 }
 
 const BookmarkNode* BookmarkModel::AddFolder(const BookmarkNode* parent,
                                              int index,
                                              const string16& title) {
-  if (!loaded_ || parent == &root_ || !IsValidIndex(parent, index, true)) {
+  if (!loaded_ || parent == root_node() || !IsValidIndex(parent, index, true)) {
     // Can't add to the root.
     NOTREACHED();
     return NULL;
   }
 
   BookmarkNode* new_node = new BookmarkNode(generate_next_node_id(), GURL());
   new_node->set_date_folder_modified(Time::Now());
   new_node->set_title(title);
   new_node->set_type(BookmarkNode::FOLDER);
 
   return AddNode(AsMutable(parent), index, new_node, false);
 }
 
 const BookmarkNode* BookmarkModel::AddURL(const BookmarkNode* parent,
                                           int index,
                                           const string16& title,
                                           const GURL& url) {
   return AddURLWithCreationTime(parent, index, title, url, Time::Now());
 }
 
 const BookmarkNode* BookmarkModel::AddURLWithCreationTime(
     const BookmarkNode* parent,
     int index,
     const string16& title,
     const GURL& url,
     const Time& creation_time) {
-  if (!loaded_ || !url.is_valid() || is_root(parent) ||
+  if (!loaded_ || !url.is_valid() || parent == root_node() ||
       !IsValidIndex(parent, index, true)) {
     NOTREACHED();
     return NULL;
   }
 
   bool was_bookmarked = IsBookmarked(url);
 
   SetDateFolderModified(parent, creation_time);
 
   BookmarkNode* new_node = new BookmarkNode(generate_next_node_id(), url);
   new_node->set_title(title);
   new_node->set_date_added(creation_time);
   new_node->set_type(BookmarkNode::URL);
 
   {
     // Only hold the lock for the duration of the insert.
     base::AutoLock url_lock(url_lock_);
     nodes_ordered_by_url_set_.insert(new_node);
   }
 
   return AddNode(AsMutable(parent), index, new_node, was_bookmarked);
 }
 
 void BookmarkModel::SortChildren(const BookmarkNode* parent) {
-  if (!parent || !parent->is_folder() || is_root(parent) ||
+  if (!parent || !parent->is_folder() || parent == root_node() ||
       parent->child_count() <= 1) {
     return;
   }
 
   UErrorCode error = U_ZERO_ERROR;
   scoped_ptr<icu::Collator> collator(
       icu::Collator::createInstance(
           icu::Locale(g_browser_process->GetApplicationLocale().c_str()),
           error));
   if (U_FAILURE(error))
@@ skipping 359 matching lines @@
 
 void BookmarkModel::SetFileChanged() {
   file_changed_ = true;
 }
 
 BookmarkLoadDetails* BookmarkModel::CreateLoadDetails() {
   BookmarkNode* bb_node = CreatePermanentNode(BookmarkNode::BOOKMARK_BAR);
   BookmarkNode* other_node = CreatePermanentNode(BookmarkNode::OTHER_NODE);
   BookmarkNode* synced_node = CreatePermanentNode(BookmarkNode::SYNCED);
   return new BookmarkLoadDetails(bb_node, other_node, synced_node,
-                                 new BookmarkIndex(profile()), next_node_id_);
+                                 new BookmarkIndex(profile_), next_node_id_);
 }