Make bookmark model public interface use const BookmarkNode* instead of

BookmarkNode*. This helps in making the BookmarkNode class setters public
also without worrying about someone inadvertently changing BookmarkNode
properties directly for bookmark model bookmarks.

Change all the call sites to reflect this.

BUG=none
TEST=none

Review URL: http://codereview.chromium.org/146116

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@19428 0039d316-1c4b-4281-b951-d872f2087c98

85 files changed, 1208 insertions, 1089 deletions

diff --git a/app/tree_node_model.h b/app/tree_node_model.h
index 7767d49..7d96438 100644
--- a/app/tree_node_model.h
+++ b/app/tree_node_model.h
@@ -100,7 +100,7 @@ class TreeNode : public TreeModelNode {
   }
 
   // Returns the number of children.
-  int GetChildCount() {
+  int GetChildCount() const {
     return static_cast<int>(children_->size());
   }
 
@@ -109,16 +109,23 @@ class TreeNode : public TreeModelNode {
     DCHECK(index >= 0 && index < GetChildCount());
     return children_[index];
   }
+  const NodeType* GetChild(int index) const {
+    DCHECK(index >= 0 && index < GetChildCount());
+    return children_[index];
+  }
 
   // Returns the parent.
   NodeType* GetParent() {
     return parent_;
   }
+  const NodeType* GetParent() const {
+    return parent_;
+  }
 
   // Returns the index of the specified child, or -1 if node is a not a child.
-  int IndexOfChild(const NodeType* node) {
+  int IndexOfChild(const NodeType* node) const {
     DCHECK(node);
-    typename std::vector<NodeType*>::iterator i =
+    typename std::vector<NodeType*>::const_iterator i =
         std::find(children_->begin(), children_->end(), node);
     if (i != children_->end())
       return static_cast<int>(i - children_->begin());
@@ -136,11 +143,11 @@ class TreeNode : public TreeModelNode {
   }
 
   // Returns true if this is the root.
-  bool IsRoot() { return (parent_ == NULL); }
+  bool IsRoot() const { return (parent_ == NULL); }
 
   // Returns true if this == ancestor, or one of this nodes parents is
   // ancestor.
-  bool HasAncestor(NodeType* ancestor) const {
+  bool HasAncestor(const NodeType* ancestor) const {
     if (ancestor == this)
       return true;
     if (!ancestor)
diff --git a/chrome/browser/bookmarks/base_bookmark_model_observer.h b/chrome/browser/bookmarks/base_bookmark_model_observer.h
index 34d755f..045afb9 100644
--- a/chrome/browser/bookmarks/base_bookmark_model_observer.h
+++ b/chrome/browser/bookmarks/base_bookmark_model_observer.h
@@ -22,31 +22,31 @@ class BaseBookmarkModelObserver : public BookmarkModelObserver {
     BookmarkModelChanged();
   }
   virtual void BookmarkNodeMoved(BookmarkModel* model,
-                                 BookmarkNode* old_parent,
+                                 const BookmarkNode* old_parent,
                                  int old_index,
-                                 BookmarkNode* new_parent,
+                                 const BookmarkNode* new_parent,
                                  int new_index) {
     BookmarkModelChanged();
   }
   virtual void BookmarkNodeAdded(BookmarkModel* model,
-                                 BookmarkNode* parent,
+                                 const BookmarkNode* parent,
                                  int index) {
     BookmarkModelChanged();
   }
   virtual void BookmarkNodeRemoved(BookmarkModel* model,
-                                   BookmarkNode* parent,
+                                   const BookmarkNode* parent,
                                    int index) {
     BookmarkModelChanged();
   }
   virtual void BookmarkNodeChanged(BookmarkModel* model,
-                                   BookmarkNode* node) {
+                                   const BookmarkNode* node) {
     BookmarkModelChanged();
   }
   virtual void BookmarkNodeFavIconLoaded(BookmarkModel* model,
-                                         BookmarkNode* node) {
+                                         const BookmarkNode* node) {
   }
   virtual void BookmarkNodeChildrenReordered(BookmarkModel* model,
-                                             BookmarkNode* node) {
+                                             const BookmarkNode* node) {
     BookmarkModelChanged();
   }
 
diff --git a/chrome/browser/bookmarks/bookmark_codec.cc b/chrome/browser/bookmarks/bookmark_codec.cc
index 03b7028..c9c8366 100644
--- a/chrome/browser/bookmarks/bookmark_codec.cc
+++ b/chrome/browser/bookmarks/bookmark_codec.cc
@@ -96,8 +96,8 @@ Value* BookmarkCodec::Encode(BookmarkModel* model) {
   return Encode(model->GetBookmarkBarNode(), model->other_node());
 }
 
-Value* BookmarkCodec::Encode(BookmarkNode* bookmark_bar_node,
-                             BookmarkNode* other_folder_node) {
+Value* BookmarkCodec::Encode(const BookmarkNode* bookmark_bar_node,
+                             const BookmarkNode* other_folder_node) {
   InitializeChecksum();
   DictionaryValue* roots = new DictionaryValue();
   roots->Set(kRootFolderNameKey, EncodeNode(bookmark_bar_node));
@@ -127,7 +127,7 @@ bool BookmarkCodec::Decode(BookmarkNode* bb_node,
   return success;
 }
 
-Value* BookmarkCodec::EncodeNode(BookmarkNode* node) {
+Value* BookmarkCodec::EncodeNode(const BookmarkNode* node) {
   DictionaryValue* value = new DictionaryValue();
   std::string id;
   if (persist_ids_) {
@@ -203,8 +203,8 @@ bool BookmarkCodec::DecodeHelper(BookmarkNode* bb_node,
   // Need to reset the type as decoding resets the type to FOLDER. Similarly
   // we need to reset the title as the title is persisted and restored from
   // the file.
-  bb_node->type_ = history::StarredEntry::BOOKMARK_BAR;
-  other_folder_node->type_ = history::StarredEntry::OTHER;
+  bb_node->SetType(history::StarredEntry::BOOKMARK_BAR);
+  other_folder_node->SetType(history::StarredEntry::OTHER);
   bb_node->SetTitle(l10n_util::GetString(IDS_BOOMARK_BAR_FOLDER_NAME));
   other_folder_node->SetTitle(
       l10n_util::GetString(IDS_BOOMARK_BAR_OTHER_FOLDER_NAME));
@@ -266,7 +266,7 @@ bool BookmarkCodec::DecodeNode(const DictionaryValue& value,
 
     if (parent)
       parent->Add(parent->GetChildCount(), node);
-    node->type_ = history::StarredEntry::URL;
+    node->SetType(history::StarredEntry::URL);
     UpdateChecksumWithUrlNode(id_string, title, url_string);
   } else {
     std::wstring last_modified_date;
@@ -288,9 +288,9 @@ bool BookmarkCodec::DecodeNode(const DictionaryValue& value,
       node->set_id(id);
     }
 
-    node->type_ = history::StarredEntry::USER_GROUP;
-    node->date_group_modified_ = Time::FromInternalValue(
-        StringToInt64(WideToUTF16Hack(last_modified_date)));
+    node->SetType(history::StarredEntry::USER_GROUP);
+    node->set_date_group_modified(Time::FromInternalValue(
+        StringToInt64(WideToUTF16Hack(last_modified_date))));
 
     if (parent)
       parent->Add(parent->GetChildCount(), node);
@@ -301,8 +301,8 @@ bool BookmarkCodec::DecodeNode(const DictionaryValue& value,
   }
 
   node->SetTitle(title);
-  node->date_added_ = Time::FromInternalValue(
-      StringToInt64(WideToUTF16Hack(date_added_string)));
+  node->set_date_added(Time::FromInternalValue(
+      StringToInt64(WideToUTF16Hack(date_added_string))));
   return true;
 }
 
diff --git a/chrome/browser/bookmarks/bookmark_codec.h b/chrome/browser/bookmarks/bookmark_codec.h
index 6631ec5..e6292a8 100644
--- a/chrome/browser/bookmarks/bookmark_codec.h
+++ b/chrome/browser/bookmarks/bookmark_codec.h
@@ -78,8 +78,8 @@ class BookmarkCodec {
   // up to the caller to delete the returned object.
   // This method is public for use by StarredURLDatabase in migrating the
   // bookmarks out of the database.
-  Value* Encode(BookmarkNode* bookmark_bar_node,
-                BookmarkNode* other_folder_node);
+  Value* Encode(const BookmarkNode* bookmark_bar_node,
+                const BookmarkNode* other_folder_node);
 
   // Decodes the previously encoded value to the specified nodes as well as
   // setting |max_node_id| to the greatest node id. Returns true on success,
@@ -122,7 +122,7 @@ class BookmarkCodec {
  private:
   // Encodes node and all its children into a Value object and returns it.
   // The caller takes ownership of the returned object.
-  Value* EncodeNode(BookmarkNode* node);
+  Value* EncodeNode(const BookmarkNode* node);
 
   // Helper to perform decoding.
   bool DecodeHelper(BookmarkNode* bb_node,
diff --git a/chrome/browser/bookmarks/bookmark_codec_unittest.cc b/chrome/browser/bookmarks/bookmark_codec_unittest.cc
index 83df11d..d6a3424 100644
--- a/chrome/browser/bookmarks/bookmark_codec_unittest.cc
+++ b/chrome/browser/bookmarks/bookmark_codec_unittest.cc
@@ -24,29 +24,34 @@ const wchar_t kUrl4Url[] = L"http://www.url4.com";
 const wchar_t kGroup1Title[] = L"group1";
 const wchar_t kGroup2Title[] = L"group2";
 
+// Helper to get a mutable bookmark node.
+static BookmarkNode* AsMutable(const BookmarkNode* node) {
+  return const_cast<BookmarkNode*>(node);
 }
 
+}  // anonymous namespace
+
 class BookmarkCodecTest : public testing::Test {
  protected:
   // Helpers to create bookmark models with different data.
   BookmarkModel* CreateTestModel1() {
     scoped_ptr<BookmarkModel> model(new BookmarkModel(NULL));
-    BookmarkNode* bookmark_bar = model->GetBookmarkBarNode();
+    const BookmarkNode* bookmark_bar = model->GetBookmarkBarNode();
     model->AddURL(bookmark_bar, 0, kUrl1Title, GURL(kUrl1Url));
     return model.release();
   }
   BookmarkModel* CreateTestModel2() {
     scoped_ptr<BookmarkModel> model(new BookmarkModel(NULL));
-    BookmarkNode* bookmark_bar = model->GetBookmarkBarNode();
+    const BookmarkNode* bookmark_bar = model->GetBookmarkBarNode();
     model->AddURL(bookmark_bar, 0, kUrl1Title, GURL(kUrl1Url));
     model->AddURL(bookmark_bar, 1, kUrl2Title, GURL(kUrl2Url));
     return model.release();
   }
   BookmarkModel* CreateTestModel3() {
     scoped_ptr<BookmarkModel> model(new BookmarkModel(NULL));
-    BookmarkNode* bookmark_bar = model->GetBookmarkBarNode();
+    const BookmarkNode* bookmark_bar = model->GetBookmarkBarNode();
     model->AddURL(bookmark_bar, 0, kUrl1Title, GURL(kUrl1Url));
-    BookmarkNode* group1 = model->AddGroup(bookmark_bar, 1, kGroup1Title);
+    const BookmarkNode* group1 = model->AddGroup(bookmark_bar, 1, kGroup1Title);
     model->AddURL(group1, 0, kUrl2Title, GURL(kUrl2Url));
     return model.release();
   }
@@ -90,7 +95,7 @@ class BookmarkCodecTest : public testing::Test {
     scoped_ptr<Value> value(encoder.Encode(model));
     const std::string& computed_checksum = encoder.computed_checksum();
     const std::string& stored_checksum = encoder.stored_checksum();
- 
+
     // Computed and stored checksums should not be empty and should be equal.
     EXPECT_FALSE(computed_checksum.empty());
     EXPECT_FALSE(stored_checksum.empty());
@@ -102,8 +107,9 @@ class BookmarkCodecTest : public testing::Test {
 
   bool Decode(BookmarkCodec* codec, BookmarkModel* model, const Value& value) {
     int max_id;
-    bool result = codec->Decode(model->GetBookmarkBarNode(),
-                                model->other_node(), &max_id, value);
+    bool result = codec->Decode(AsMutable(model->GetBookmarkBarNode()),
+                                AsMutable(model->other_node()),
+                                &max_id, value);
     model->set_next_node_id(max_id);
     return result;
   }
@@ -122,7 +128,7 @@ class BookmarkCodecTest : public testing::Test {
 
     *computed_checksum = decoder.computed_checksum();
     const std::string& stored_checksum = decoder.stored_checksum();
- 
+
     // Computed and stored checksums should not be empty.
     EXPECT_FALSE(computed_checksum->empty());
     EXPECT_FALSE(stored_checksum.empty());
@@ -207,10 +213,10 @@ TEST_F(BookmarkCodecTest, PersistIDsTest) {
 
   // Add a couple of more items to the decoded bookmark model and make sure
   // ID persistence is working properly.
-  BookmarkNode* bookmark_bar = decoded_model.GetBookmarkBarNode();
+  const BookmarkNode* bookmark_bar = decoded_model.GetBookmarkBarNode();
   decoded_model.AddURL(
       bookmark_bar, bookmark_bar->GetChildCount(), kUrl3Title, GURL(kUrl3Url));
-  BookmarkNode* group2_node = decoded_model.AddGroup(
+  const BookmarkNode* group2_node = decoded_model.AddGroup(
       bookmark_bar, bookmark_bar->GetChildCount(), kGroup2Title);
   decoded_model.AddURL(group2_node, 0, kUrl4Title, GURL(kUrl4Url));
 
diff --git a/chrome/browser/bookmarks/bookmark_drag_data.cc b/chrome/browser/bookmarks/bookmark_drag_data.cc
index a6ae333..732d119 100644
--- a/chrome/browser/bookmarks/bookmark_drag_data.cc
+++ b/chrome/browser/bookmarks/bookmark_drag_data.cc
@@ -28,7 +28,7 @@ static void RegisterFormat() {
 }
 #endif
 
-BookmarkDragData::Element::Element(BookmarkNode* node)
+BookmarkDragData::Element::Element(const BookmarkNode* node)
     : is_url(node->is_url()),
       url(node->GetURL()),
       title(node->GetTitle()),
@@ -76,11 +76,12 @@ bool BookmarkDragData::Element::ReadFromPickle(Pickle* pickle,
   return true;
 }
 
-BookmarkDragData::BookmarkDragData(BookmarkNode* node) {
+BookmarkDragData::BookmarkDragData(const BookmarkNode* node) {
   elements.push_back(Element(node));
 }
 
-BookmarkDragData::BookmarkDragData(const std::vector<BookmarkNode*>& nodes) {
+BookmarkDragData::BookmarkDragData(
+    const std::vector<const BookmarkNode*>& nodes) {
   for (size_t i = 0; i < nodes.size(); ++i)
     elements.push_back(Element(nodes[i]));
 }
@@ -185,14 +186,15 @@ bool BookmarkDragData::ReadFromPickle(Pickle* pickle) {
   return true;
 }
 
-std::vector<BookmarkNode*> BookmarkDragData::GetNodes(Profile* profile) const {
-  std::vector<BookmarkNode*> nodes;
+std::vector<const BookmarkNode*> BookmarkDragData::GetNodes(
+    Profile* profile) const {
+  std::vector<const BookmarkNode*> nodes;
 
   if (!IsFromProfile(profile))
     return nodes;
 
   for (size_t i = 0; i < elements.size(); ++i) {
-    BookmarkNode* node =
+    const BookmarkNode* node =
         profile->GetBookmarkModel()->GetNodeByID(elements[i].id_);
     if (!node) {
       nodes.clear();
@@ -203,8 +205,8 @@ std::vector<BookmarkNode*> BookmarkDragData::GetNodes(Profile* profile) const {
   return nodes;
 }
 
-BookmarkNode* BookmarkDragData::GetFirstNode(Profile* profile) const {
-  std::vector<BookmarkNode*> nodes = GetNodes(profile);
+const BookmarkNode* BookmarkDragData::GetFirstNode(Profile* profile) const {
+  std::vector<const BookmarkNode*> nodes = GetNodes(profile);
   return nodes.size() == 1 ? nodes[0] : NULL;
 }
 
diff --git a/chrome/browser/bookmarks/bookmark_drag_data.h b/chrome/browser/bookmarks/bookmark_drag_data.h
index 5e8db56..88cb6d4 100644
--- a/chrome/browser/bookmarks/bookmark_drag_data.h
+++ b/chrome/browser/bookmarks/bookmark_drag_data.h
@@ -38,7 +38,7 @@ class Profile;
 struct BookmarkDragData {
   // Element represents a single node.
   struct Element {
-    explicit Element(BookmarkNode* node);
+    explicit Element(const BookmarkNode* node);
 
     Element() : is_url(false), id_(0) {}
 
@@ -68,8 +68,8 @@ struct BookmarkDragData {
   BookmarkDragData() { }
 
   // Created a BookmarkDragData populated from the arguments.
-  explicit BookmarkDragData(BookmarkNode* node);
-  explicit BookmarkDragData(const std::vector<BookmarkNode*>& nodes);
+  explicit BookmarkDragData(const BookmarkNode* node);
+  explicit BookmarkDragData(const std::vector<const BookmarkNode*>& nodes);
 
 #if defined(TOOLKIT_VIEWS)
   // Writes elements to data. If there is only one element and it is a URL
@@ -93,11 +93,11 @@ struct BookmarkDragData {
   // created from the same profile then the nodes from the model are returned.
   // If the nodes can't be found (may have been deleted), an empty vector is
   // returned.
-  std::vector<BookmarkNode*> GetNodes(Profile* profile) const;
+  std::vector<const BookmarkNode*> GetNodes(Profile* profile) const;
 
   // Convenience for getting the first node. Returns NULL if the data doesn't
   // match any nodes or there is more than one node.
-  BookmarkNode* GetFirstNode(Profile* profile) const;
+  const BookmarkNode* GetFirstNode(Profile* profile) const;
 
   // Do we contain valid data?
   bool is_valid() const { return !elements.empty(); }
diff --git a/chrome/browser/bookmarks/bookmark_drag_data_unittest.cc b/chrome/browser/bookmarks/bookmark_drag_data_unittest.cc
index 9507196..02b2016 100644
--- a/chrome/browser/bookmarks/bookmark_drag_data_unittest.cc
+++ b/chrome/browser/bookmarks/bookmark_drag_data_unittest.cc
@@ -51,10 +51,10 @@ TEST_F(BookmarkDragDataTest, URL) {
   profile.CreateBookmarkModel(false);
   profile.SetID(L"id");
   BookmarkModel* model = profile.GetBookmarkModel();
-  BookmarkNode* root = model->GetBookmarkBarNode();
+  const BookmarkNode* root = model->GetBookmarkBarNode();
   GURL url(GURL("http://foo.com"));
   const std::wstring title(L"blah");
-  BookmarkNode* node = model->AddURL(root, 0, title, url);
+  const BookmarkNode* node = model->AddURL(root, 0, title, url);
   BookmarkDragData drag_data(node);
   EXPECT_TRUE(drag_data.is_valid());
   ASSERT_EQ(1, drag_data.elements.size());
@@ -93,10 +93,10 @@ TEST_F(BookmarkDragDataTest, Group) {
   profile.CreateBookmarkModel(false);
   profile.SetID(L"id");
   BookmarkModel* model = profile.GetBookmarkModel();
-  BookmarkNode* root = model->GetBookmarkBarNode();
-  BookmarkNode* g1 = model->AddGroup(root, 0, L"g1");
-  BookmarkNode* g11 = model->AddGroup(g1, 0, L"g11");
-  BookmarkNode* g12 = model->AddGroup(g1, 0, L"g12");
+  const BookmarkNode* root = model->GetBookmarkBarNode();
+  const BookmarkNode* g1 = model->AddGroup(root, 0, L"g1");
+  const BookmarkNode* g11 = model->AddGroup(g1, 0, L"g11");
+  const BookmarkNode* g12 = model->AddGroup(g1, 0, L"g12");
 
   BookmarkDragData drag_data(g12);
   EXPECT_TRUE(drag_data.is_valid());
@@ -117,7 +117,7 @@ TEST_F(BookmarkDragDataTest, Group) {
   EXPECT_FALSE(read_data.elements[0].is_url);
 
   // We should get back the same node when asking for the same profile.
-  BookmarkNode* r_g12 = read_data.GetFirstNode(&profile);
+  const BookmarkNode* r_g12 = read_data.GetFirstNode(&profile);
   EXPECT_TRUE(g12 == r_g12);
 
   // A different profile should return NULL for the node.
@@ -131,8 +131,8 @@ TEST_F(BookmarkDragDataTest, GroupWithChild) {
   profile.SetID(L"id");
   profile.CreateBookmarkModel(false);
   BookmarkModel* model = profile.GetBookmarkModel();
-  BookmarkNode* root = model->GetBookmarkBarNode();
-  BookmarkNode* group = model->AddGroup(root, 0, L"g1");
+  const BookmarkNode* root = model->GetBookmarkBarNode();
+  const BookmarkNode* group = model->AddGroup(root, 0, L"g1");
 
   GURL url(GURL("http://foo.com"));
   const std::wstring title(L"blah2");
@@ -159,7 +159,7 @@ TEST_F(BookmarkDragDataTest, GroupWithChild) {
   EXPECT_TRUE(read_child.is_url);
 
   // And make sure we get the node back.
-  BookmarkNode* r_group = read_data.GetFirstNode(&profile);
+  const BookmarkNode* r_group = read_data.GetFirstNode(&profile);
   EXPECT_TRUE(group == r_group);
 }
 
@@ -169,16 +169,16 @@ TEST_F(BookmarkDragDataTest, MultipleNodes) {
   profile.SetID(L"id");
   profile.CreateBookmarkModel(false);
   BookmarkModel* model = profile.GetBookmarkModel();
-  BookmarkNode* root = model->GetBookmarkBarNode();
-  BookmarkNode* group = model->AddGroup(root, 0, L"g1");
+  const BookmarkNode* root = model->GetBookmarkBarNode();
+  const BookmarkNode* group = model->AddGroup(root, 0, L"g1");
 
   GURL url(GURL("http://foo.com"));
   const std::wstring title(L"blah2");
 
-  BookmarkNode* url_node = model->AddURL(group, 0, title, url);
+  const BookmarkNode* url_node = model->AddURL(group, 0, title, url);
 
   // Write the nodes to the clipboard.
-  std::vector<BookmarkNode*> nodes;
+  std::vector<const BookmarkNode*> nodes;
   nodes.push_back(group);
   nodes.push_back(url_node);
   BookmarkDragData drag_data(nodes);
@@ -204,7 +204,7 @@ TEST_F(BookmarkDragDataTest, MultipleNodes) {
   EXPECT_EQ(0, read_url.children.size());
 
   // And make sure we get the node back.
-  std::vector<BookmarkNode*> read_nodes = read_data.GetNodes(&profile);
+  std::vector<const BookmarkNode*> read_nodes = read_data.GetNodes(&profile);
   ASSERT_EQ(2, read_nodes.size());
   EXPECT_TRUE(read_nodes[0] == group);
   EXPECT_TRUE(read_nodes[1] == url_node);
diff --git a/chrome/browser/bookmarks/bookmark_editor.h b/chrome/browser/bookmarks/bookmark_editor.h
index 54996db..b7dc15b 100644
--- a/chrome/browser/bookmarks/bookmark_editor.h
+++ b/chrome/browser/bookmarks/bookmark_editor.h
@@ -19,7 +19,7 @@ class BookmarkEditor {
   class Handler {
    public:
     virtual ~Handler() {}
-    virtual void NodeCreated(BookmarkNode* new_node) = 0;
+    virtual void NodeCreated(const BookmarkNode* new_node) = 0;
   };
 
   // An enumeration of the possible configurations offered.
@@ -35,8 +35,8 @@ class BookmarkEditor {
   // null. See description of Handler for details.
   static void Show(gfx::NativeView parent_window,
                    Profile* profile,
-                   BookmarkNode* parent,
-                   BookmarkNode* node,
+                   const BookmarkNode* parent,
+                   const BookmarkNode* node,
                    Configuration configuration,
                    Handler* handler);
 };
diff --git a/chrome/browser/bookmarks/bookmark_folder_tree_model.cc b/chrome/browser/bookmarks/bookmark_folder_tree_model.cc
index ad03b61..b04379a 100644
--- a/chrome/browser/bookmarks/bookmark_folder_tree_model.cc
+++ b/chrome/browser/bookmarks/bookmark_folder_tree_model.cc
@@ -40,14 +40,14 @@ BookmarkFolderTreeModel::NodeType BookmarkFolderTreeModel::GetNodeType(
 }
 
 FolderNode* BookmarkFolderTreeModel::GetFolderNodeForBookmarkNode(
-    BookmarkNode* node) {
+    const BookmarkNode* node) {
   if (!node->is_folder())
     return NULL;
 
   return GetFolderNodeForBookmarkNode(AsNode(GetRoot()), node);
 }
 
-BookmarkNode* BookmarkFolderTreeModel::TreeNodeAsBookmarkNode(
+const BookmarkNode* BookmarkFolderTreeModel::TreeNodeAsBookmarkNode(
     TreeModelNode* node) {
   if (GetNodeType(node) != BOOKMARK)
     return NULL;
@@ -65,11 +65,11 @@ void BookmarkFolderTreeModel::BookmarkModelBeingDeleted(BookmarkModel* model) {
 }
 
 void BookmarkFolderTreeModel::BookmarkNodeMoved(BookmarkModel* model,
-                                                BookmarkNode* old_parent,
+                                                const BookmarkNode* old_parent,
                                                 int old_index,
-                                                BookmarkNode* new_parent,
+                                                const BookmarkNode* new_parent,
                                                 int new_index) {
-  BookmarkNode* moved_node = new_parent->GetChild(new_index);
+  const BookmarkNode* moved_node = new_parent->GetChild(new_index);
   if (!moved_node->is_folder())
     return;  // We're only showing folders, so we can ignore this.
 
@@ -84,9 +84,9 @@ void BookmarkFolderTreeModel::BookmarkNodeMoved(BookmarkModel* model,
 }
 
 void BookmarkFolderTreeModel::BookmarkNodeAdded(BookmarkModel* model,
-                                                BookmarkNode* parent,
+                                                const BookmarkNode* parent,
                                                 int index) {
-  BookmarkNode* new_node = parent->GetChild(index);
+  const BookmarkNode* new_node = parent->GetChild(index);
   if (!new_node->is_folder())
     return;  // We're only showing folders, so we can ignore this.
 
@@ -96,9 +96,9 @@ void BookmarkFolderTreeModel::BookmarkNodeAdded(BookmarkModel* model,
 }
 
 void BookmarkFolderTreeModel::BookmarkNodeRemoved(BookmarkModel* model,
-                                                  BookmarkNode* parent,
+                                                  const BookmarkNode* parent,
                                                   int index,
-                                                  BookmarkNode* node) {
+                                                  const BookmarkNode* node) {
   if (!node->is_folder())
     return;  // We're only showing folders.
 
@@ -117,7 +117,7 @@ void BookmarkFolderTreeModel::BookmarkNodeRemoved(BookmarkModel* model,
 }
 
 void BookmarkFolderTreeModel::BookmarkNodeChanged(BookmarkModel* model,
-                                                  BookmarkNode* node) {
+                                                  const BookmarkNode* node) {
   if (!node->is_folder())
     return;
 
@@ -132,14 +132,14 @@ void BookmarkFolderTreeModel::BookmarkNodeChanged(BookmarkModel* model,
 
 void BookmarkFolderTreeModel::BookmarkNodeChildrenReordered(
     BookmarkModel* model,
-    BookmarkNode* node) {
+    const BookmarkNode* node) {
   FolderNode* folder_node = GetFolderNodeForBookmarkNode(node);
   DCHECK(folder_node);
   if (folder_node->GetChildCount() <= 1)
     return;  // Order won't have changed if 1 or fewer nodes.
 
   // Build a map between folder node and bookmark node.
-  std::map<BookmarkNode*, FolderNode*> bn_to_folder;
+  std::map<const BookmarkNode*, FolderNode*> bn_to_folder;
   for (int i = 0; i < folder_node->GetChildCount(); ++i)
     bn_to_folder[folder_node->GetChild(i)->value] = folder_node->GetChild(i);
 
@@ -149,7 +149,7 @@ void BookmarkFolderTreeModel::BookmarkNodeChildrenReordered(
 
   // And add them back in the new order.
   for (int i = 0; i < node->GetChildCount(); ++i) {
-    BookmarkNode* child = node->GetChild(i);
+    const BookmarkNode* child = node->GetChild(i);
     if (child->is_folder()) {
       DCHECK(bn_to_folder.find(child) != bn_to_folder.end());
       folder_node->Add(folder_node->GetChildCount(), bn_to_folder[child]);
@@ -189,7 +189,7 @@ void BookmarkFolderTreeModel::AddRootChildren() {
 
 FolderNode* BookmarkFolderTreeModel::GetFolderNodeForBookmarkNode(
     FolderNode* folder_node,
-    BookmarkNode* node) {
+    const BookmarkNode* node) {
   DCHECK(node->is_folder());
   if (folder_node->value == node)
     return folder_node;
@@ -202,25 +202,26 @@ FolderNode* BookmarkFolderTreeModel::GetFolderNodeForBookmarkNode(
   return NULL;
 }
 
-FolderNode* BookmarkFolderTreeModel::CreateFolderNode(BookmarkNode* node) {
+FolderNode* BookmarkFolderTreeModel::CreateFolderNode(
+    const BookmarkNode* node) {
   DCHECK(node->is_folder());
   FolderNode* folder_node = new FolderNode(node);
   folder_node->SetTitle(node->GetTitle());
 
   // And clone the children folders.
   for (int i = 0; i < node->GetChildCount(); ++i) {
-    BookmarkNode* child = node->GetChild(i);
+    const BookmarkNode* child = node->GetChild(i);
     if (child->is_folder())
       folder_node->Add(folder_node->GetChildCount(), CreateFolderNode(child));
   }
   return folder_node;
 }
 
-int BookmarkFolderTreeModel::CalculateIndexForChild(BookmarkNode* node) {
-  BookmarkNode* parent = node->GetParent();
+int BookmarkFolderTreeModel::CalculateIndexForChild(const BookmarkNode* node) {
+  const BookmarkNode* parent = node->GetParent();
   DCHECK(parent);
   for (int i = 0, folder_count = 0; i < parent->GetChildCount(); ++i) {
-    BookmarkNode* child = parent->GetChild(i);
+    const BookmarkNode* child = parent->GetChild(i);
     if (child == node)
       return folder_count;
     if (child->is_folder())
diff --git a/chrome/browser/bookmarks/bookmark_folder_tree_model.h b/chrome/browser/bookmarks/bookmark_folder_tree_model.h
index 4faff4e..fb88e1c 100644
--- a/chrome/browser/bookmarks/bookmark_folder_tree_model.h
+++ b/chrome/browser/bookmarks/bookmark_folder_tree_model.h
@@ -11,7 +11,7 @@
 #include "chrome/browser/bookmarks/bookmark_model.h"
 
 // The type of nodes created by BookmarkFolderTreeModel.
-typedef TreeNodeWithValue<BookmarkNode*> FolderNode;
+typedef TreeNodeWithValue<const BookmarkNode*> FolderNode;
 
 // TreeModel implementation that shows the folders from the BookmarkModel.
 // The root node contains the following nodes:
@@ -40,11 +40,11 @@ class BookmarkFolderTreeModel : public TreeNodeModel<FolderNode>,
   NodeType GetNodeType(TreeModelNode* node);
 
   // Returns the FolderNode for the specified BookmarkNode.
-  FolderNode* GetFolderNodeForBookmarkNode(BookmarkNode* node);
+  FolderNode* GetFolderNodeForBookmarkNode(const BookmarkNode* node);
 
   // Converts the tree node into a BookmarkNode. Returns NULL if |node| is NULL
   // or not of NodeType::BOOKMARK.
-  BookmarkNode* TreeNodeAsBookmarkNode(TreeModelNode* node);
+  const BookmarkNode* TreeNodeAsBookmarkNode(TreeModelNode* node);
 
   // Returns the search node.
   FolderNode* search_node() const { return search_node_; }
@@ -53,24 +53,24 @@ class BookmarkFolderTreeModel : public TreeNodeModel<FolderNode>,
   virtual void Loaded(BookmarkModel* model);
   virtual void BookmarkModelBeingDeleted(BookmarkModel* model);
   virtual void BookmarkNodeMoved(BookmarkModel* model,
-                                 BookmarkNode* old_parent,
+                                 const BookmarkNode* old_parent,
                                  int old_index,
-                                 BookmarkNode* new_parent,
+                                 const BookmarkNode* new_parent,
                                  int new_index);
   virtual void BookmarkNodeAdded(BookmarkModel* model,
-                                 BookmarkNode* parent,
+                                 const BookmarkNode* parent,
                                  int index);
   virtual void BookmarkNodeRemoved(BookmarkModel* model,
-                                   BookmarkNode* parent,
+                                   const BookmarkNode* parent,
                                    int index,
-                                   BookmarkNode* node);
+                                   const BookmarkNode* node);
   virtual void BookmarkNodeChanged(BookmarkModel* model,
-                                   BookmarkNode* node);
+                                   const BookmarkNode* node);
   virtual void BookmarkNodeChildrenReordered(BookmarkModel* model,
-                                             BookmarkNode* node);
+                                             const BookmarkNode* node);
   // Folders don't have favicons, so we ignore this.
   virtual void BookmarkNodeFavIconLoaded(BookmarkModel* model,
-                                         BookmarkNode* node) {}
+                                         const BookmarkNode* node) {}
 
   // The following are overriden to return custom icons for the recently
   // bookmarked and search nodes.
@@ -85,17 +85,17 @@ private:
   // represents |node|, |folder_node| is returned, otherwise this recurses
   // through the children.
   FolderNode* GetFolderNodeForBookmarkNode(FolderNode* folder_node,
-                                           BookmarkNode* node);
+                                           const BookmarkNode* node);
 
   // Creates a new folder node for |node| and all its children.
-  FolderNode* CreateFolderNode(BookmarkNode* node);
+  FolderNode* CreateFolderNode(const BookmarkNode* node);
 
   // Returns the number of folders that precede |node| in |node|s parent.
   // The returned value is the index of the folder node representing |node|
   // in its parent.
   // This is used when new bookmarks are created to determine where the
   // corresponding folder node should be created.
-  int CalculateIndexForChild(BookmarkNode* node);
+  int CalculateIndexForChild(const BookmarkNode* node);
 
   // The model we're getting data from. Owned by the Profile.
   BookmarkModel* model_;
diff --git a/chrome/browser/bookmarks/bookmark_folder_tree_model_unittest.cc b/chrome/browser/bookmarks/bookmark_folder_tree_model_unittest.cc
index ce50564..ddefae0 100644
--- a/chrome/browser/bookmarks/bookmark_folder_tree_model_unittest.cc
+++ b/chrome/browser/bookmarks/bookmark_folder_tree_model_unittest.cc
@@ -38,12 +38,12 @@ class BookmarkFolderTreeModelTest : public testing::Test,
     profile_.reset(new TestingProfile());
     profile_->CreateBookmarkModel(true);
     // Populate with some default data.
-    BookmarkNode* bb = bookmark_model()->GetBookmarkBarNode();
+    const BookmarkNode* bb = bookmark_model()->GetBookmarkBarNode();
     bookmark_model()->AddURL(bb, 0, L"url1", url1_);
-    BookmarkNode* f1 = bookmark_model()->AddGroup(bb, 1, L"f1");
+    const BookmarkNode* f1 = bookmark_model()->AddGroup(bb, 1, L"f1");
     bookmark_model()->AddGroup(f1, 0, L"f11");
 
-    BookmarkNode* other = bookmark_model()->other_node();
+    const BookmarkNode* other = bookmark_model()->other_node();
     bookmark_model()->AddURL(other, 0, L"url2", url2_);
     bookmark_model()->AddGroup(other, 1, L"f2");
     bookmark_model()->AddURL(other, 2, L"url3", url3_);
@@ -176,7 +176,7 @@ TEST_F(BookmarkFolderTreeModelTest, RemoveFolder) {
 
 // Adds a folder and makes sure we get the right notification.
 TEST_F(BookmarkFolderTreeModelTest, AddFolder) {
-  BookmarkNode* new_group =
+  const BookmarkNode* new_group =
       bookmark_model()->AddGroup(
           bookmark_model()->GetBookmarkBarNode(), 0, L"fa");
   VerifyAndClearObserverCounts(0, 1, 0, 0);
@@ -198,7 +198,7 @@ TEST_F(BookmarkFolderTreeModelTest, ChangeFolder) {
 // Sorts the other folder, making sure the resulting order is correct and the
 // appropriate notification is sent.
 TEST_F(BookmarkFolderTreeModelTest, Sort) {
-  BookmarkNode* other = bookmark_model()->other_node();
+  const BookmarkNode* other = bookmark_model()->other_node();
   bookmark_model()->AddGroup(other, 3, L"a1");
   bookmark_model()->AddGroup(other, 4, L"g1");
   ResetCounts();
diff --git a/chrome/browser/bookmarks/bookmark_html_writer_unittest.cc b/chrome/browser/bookmarks/bookmark_html_writer_unittest.cc
index d1f5a4e..a47e204 100644
--- a/chrome/browser/bookmarks/bookmark_html_writer_unittest.cc
+++ b/chrome/browser/bookmarks/bookmark_html_writer_unittest.cc
@@ -85,17 +85,18 @@ TEST_F(BookmarkHTMLWriterTest, Test) {
   base::Time t1(base::Time::Now());
   base::Time t2(t1 + base::TimeDelta::FromHours(1));
   base::Time t3(t1 + base::TimeDelta::FromHours(1));
-  BookmarkNode* f1 = model.AddGroup(model.GetBookmarkBarNode(), 0, f1_title);
+  const BookmarkNode* f1 = model.AddGroup(
+      model.GetBookmarkBarNode(), 0, f1_title);
   model.AddURLWithCreationTime(f1, 0, url1_title, url1, t1);
-  BookmarkNode* f2 = model.AddGroup(f1, 1, f2_title);
+  const BookmarkNode* f2 = model.AddGroup(f1, 1, f2_title);
   model.AddURLWithCreationTime(f2, 0, url2_title, url2, t2);
   model.AddURLWithCreationTime(model.GetBookmarkBarNode(), 1, url3_title, url3,
                                t3);
 
   model.AddURLWithCreationTime(model.other_node(), 0, url1_title, url1, t1);
   model.AddURLWithCreationTime(model.other_node(), 1, url2_title, url2, t2);
-  BookmarkNode* f3 = model.AddGroup(model.other_node(), 2, f3_title);
-  BookmarkNode* f4 = model.AddGroup(f3, 0, f4_title);
+  const BookmarkNode* f3 = model.AddGroup(model.other_node(), 2, f3_title);
+  const BookmarkNode* f4 = model.AddGroup(f3, 0, f4_title);
   model.AddURLWithCreationTime(f4, 0, url1_title, url1, t1);
 
   // Write to a temp file.
diff --git a/chrome/browser/bookmarks/bookmark_index.cc b/chrome/browser/bookmarks/bookmark_index.cc
index e769d74..0bdc87f 100644
--- a/chrome/browser/bookmarks/bookmark_index.cc
+++ b/chrome/browser/bookmarks/bookmark_index.cc
@@ -21,7 +21,7 @@ BookmarkIndex::NodeSet::const_iterator BookmarkIndex::Match::nodes_end() const {
   return nodes.empty() ? terms.front()->second.end() : nodes.end();
 }
 
-void BookmarkIndex::Add(BookmarkNode* node) {
+void BookmarkIndex::Add(const BookmarkNode* node) {
   if (!node->is_url())
     return;
   std::vector<std::wstring> terms = ExtractQueryWords(node->GetTitle());
@@ -29,7 +29,7 @@ void BookmarkIndex::Add(BookmarkNode* node) {
     RegisterNode(terms[i], node);
 }
 
-void BookmarkIndex::Remove(BookmarkNode* node) {
+void BookmarkIndex::Remove(const BookmarkNode* node) {
   if (!node->is_url())
     return;
 
@@ -179,7 +179,7 @@ std::vector<std::wstring> BookmarkIndex::ExtractQueryWords(
 }
 
 void BookmarkIndex::RegisterNode(const std::wstring& term,
-                                 BookmarkNode* node) {
+                                 const BookmarkNode* node) {
   if (std::find(index_[term].begin(), index_[term].end(), node) !=
       index_[term].end()) {
     // We've already added node for term.
@@ -189,7 +189,7 @@ void BookmarkIndex::RegisterNode(const std::wstring& term,
 }
 
 void BookmarkIndex::UnregisterNode(const std::wstring& term,
-                                   BookmarkNode* node) {
+                                   const BookmarkNode* node) {
   Index::iterator i = index_.find(term);
   if (i == index_.end()) {
     // We can get here if the node has the same term more than once. For
diff --git a/chrome/browser/bookmarks/bookmark_index.h b/chrome/browser/bookmarks/bookmark_index.h
index 98a6a57..f3da604 100644
--- a/chrome/browser/bookmarks/bookmark_index.h
+++ b/chrome/browser/bookmarks/bookmark_index.h
@@ -34,10 +34,10 @@ class BookmarkIndex {
   BookmarkIndex() {}
 
   // Invoked when a bookmark has been added to the model.
-  void Add(BookmarkNode* node);
+  void Add(const BookmarkNode* node);
 
   // Invoked when a bookmark has been removed from the model.
-  void Remove(BookmarkNode* node);
+  void Remove(const BookmarkNode* node);
 
   // Returns up to |max_count| of bookmarks containing the text |query|.
   void GetBookmarksWithTitlesMatching(
@@ -46,7 +46,7 @@ class BookmarkIndex {
       std::vector<bookmark_utils::TitleMatch>* results);
 
  private:
-  typedef std::set<BookmarkNode*> NodeSet;
+  typedef std::set<const BookmarkNode*> NodeSet;
   typedef std::map<std::wstring, NodeSet> Index;
 
   // Used when finding the set of bookmarks that match a query. Each match
@@ -116,10 +116,10 @@ class BookmarkIndex {
   std::vector<std::wstring> ExtractQueryWords(const std::wstring& query);
 
   // Adds |node| to |index_|.
-  void RegisterNode(const std::wstring& term, BookmarkNode* node);
+  void RegisterNode(const std::wstring& term, const BookmarkNode* node);
 
   // Removes |node| from |index_|.
-  void UnregisterNode(const std::wstring& term, BookmarkNode* node);
+  void UnregisterNode(const std::wstring& term, const BookmarkNode* node);
 
   Index index_;
 
diff --git a/chrome/browser/bookmarks/bookmark_index_unittest.cc b/chrome/browser/bookmarks/bookmark_index_unittest.cc
index 10f43f0..cfd7b2f 100644
--- a/chrome/browser/bookmarks/bookmark_index_unittest.cc
+++ b/chrome/browser/bookmarks/bookmark_index_unittest.cc
@@ -191,8 +191,8 @@ TEST_F(BookmarkIndexTest, HonorMax) {
 // Makes sure if the lower case string of a bookmark title is more characters
 // than the upper case string no match positions are returned.
 TEST_F(BookmarkIndexTest, EmptyMatchOnMultiwideLowercaseString) {
-  BookmarkNode* n1 = model_->AddURL(model_->other_node(), 0, L"\u0130 i",
-                                    GURL("http://www.google.com"));
+  const BookmarkNode* n1 = model_->AddURL(model_->other_node(), 0, L"\u0130 i",
+                                          GURL("http://www.google.com"));
 
   std::vector<bookmark_utils::TitleMatch> matches;
   model_->GetBookmarksWithTitlesMatching(L"i", 100, &matches);
diff --git a/chrome/browser/bookmarks/bookmark_manager.h b/chrome/browser/bookmarks/bookmark_manager.h
index 28a210b..4116b76 100644
--- a/chrome/browser/bookmarks/bookmark_manager.h
+++ b/chrome/browser/bookmarks/bookmark_manager.h
@@ -15,7 +15,7 @@ class BookmarkManager {
  public:
   // Select |node| in the tree view of the bookmark manager, but only if the
   // manager is showing and is for |profile|.
-  static void SelectInTree(Profile* profile, BookmarkNode* node);
+  static void SelectInTree(Profile* profile, const BookmarkNode* node);
 
   // Show the bookmark manager for |profile|. Only one bookmark manager shows
   // at a time, so if another one is showing, this does nothing.
diff --git a/chrome/browser/bookmarks/bookmark_model.cc b/chrome/browser/bookmarks/bookmark_model.cc
index 83bd08a..3a52ae6 100644
--- a/chrome/browser/bookmarks/bookmark_model.cc
+++ b/chrome/browser/bookmarks/bookmark_model.cc
@@ -19,6 +19,15 @@
 
 using base::Time;
 
+namespace {
+
+// Helper to get a mutable bookmark node.
+static BookmarkNode* AsMutable(const BookmarkNode* node) {
+  return const_cast<BookmarkNode*>(node);
+}
+
+}  // anonymous namespace
+
 // BookmarkNode ---------------------------------------------------------------
 
 BookmarkNode::BookmarkNode(const GURL& url)
@@ -60,14 +69,14 @@ const wchar_t kPrefPersistIDs[] = L"bookmarks.persist_ids";
 
 // Comparator used when sorting bookmarks. Folders are sorted first, then
   // bookmarks.
-class SortComparator : public std::binary_function<BookmarkNode*,
-                                                   BookmarkNode*,
+class SortComparator : public std::binary_function<const BookmarkNode*,
+                                                   const BookmarkNode*,
                                                    bool> {
  public:
   explicit SortComparator(Collator* collator) : collator_(collator) { }
 
   // Returns true if lhs preceeds rhs.
-  bool operator() (BookmarkNode* n1, BookmarkNode* n2) {
+  bool operator() (const BookmarkNode* n1, const BookmarkNode* n2) {
     if (n1->GetType() == n2->GetType()) {
       // Types are the same, compare the names.
       if (!collator_)
@@ -135,26 +144,25 @@ void BookmarkModel::Load() {
   store_->LoadBookmarks(CreateLoadDetails());
 }
 
-BookmarkNode* BookmarkModel::GetParentForNewNodes() {
-  std::vector<BookmarkNode*> nodes =
+const BookmarkNode* BookmarkModel::GetParentForNewNodes() {
+  std::vector<const BookmarkNode*> nodes =
       bookmark_utils::GetMostRecentlyModifiedGroups(this, 1);
   return nodes.empty() ? bookmark_bar_node_ : nodes[0];
 }
 
-void BookmarkModel::Remove(BookmarkNode* parent, int index) {
-  if (!loaded_ || !IsValidIndex(parent, index, false) || parent == &root_) {
+void BookmarkModel::Remove(const BookmarkNode* parent, int index) {
+  if (!loaded_ || !IsValidIndex(parent, index, false) || is_root(parent)) {
     NOTREACHED();
     return;
   }
-  RemoveAndDeleteNode(parent->GetChild(index));
+  RemoveAndDeleteNode(AsMutable(parent->GetChild(index)));
 }
 
-void BookmarkModel::Move(BookmarkNode* node,
-                         BookmarkNode* new_parent,
+void BookmarkModel::Move(const BookmarkNode* node,
+                         const BookmarkNode* new_parent,
                          int index) {
   if (!loaded_ || !node || !IsValidIndex(new_parent, index, true) ||
-      new_parent == &root_ || node == &root_ || node == bookmark_bar_node_ ||
-      node == other_node_) {
+      is_root(new_parent) || is_permanent_node(node)) {
     NOTREACHED();
     return;
   }
@@ -167,7 +175,7 @@ void BookmarkModel::Move(BookmarkNode* node,
 
   SetDateGroupModified(new_parent, Time::Now());
 
-  BookmarkNode* old_parent = node->GetParent();
+  const BookmarkNode* old_parent = node->GetParent();
   int old_index = old_parent->IndexOfChild(node);
 
   if (old_parent == new_parent &&
@@ -178,7 +186,8 @@ void BookmarkModel::Move(BookmarkNode* node,
 
   if (old_parent == new_parent && index > old_index)
     index--;
-  new_parent->Add(index, node);
+  BookmarkNode* mutable_new_parent = AsMutable(new_parent);
+  mutable_new_parent->Add(index, AsMutable(node));
 
   if (store_.get())
     store_->ScheduleSave();
@@ -188,16 +197,17 @@ void BookmarkModel::Move(BookmarkNode* node,
                                       new_parent, index));
 }
 
-const SkBitmap& BookmarkModel::GetFavIcon(BookmarkNode* node) {
+const SkBitmap& BookmarkModel::GetFavIcon(const BookmarkNode* node) {
   DCHECK(node);
-  if (!node->loaded_favicon_) {
-    node->loaded_favicon_ = true;
-    LoadFavIcon(node);
+  if (!node->is_favicon_loaded()) {
+    BookmarkNode* mutable_node = AsMutable(node);
+    mutable_node->set_favicon_loaded(true);
+    LoadFavIcon(mutable_node);
   }
   return node->favicon();
 }
 
-void BookmarkModel::SetTitle(BookmarkNode* node,
+void BookmarkModel::SetTitle(const BookmarkNode* node,
                              const std::wstring& title) {
   if (!node) {
     NOTREACHED();
@@ -209,9 +219,7 @@ void BookmarkModel::SetTitle(BookmarkNode* node,
   // The title index doesn't support changing the title, instead we remove then
   // add it back.
   index_->Remove(node);
-
-  node->SetTitle(title);
-
+  AsMutable(node)->SetTitle(title);
   index_->Add(node);
 
   if (store_.get())
@@ -222,7 +230,7 @@ void BookmarkModel::SetTitle(BookmarkNode* node,
 }
 
 void BookmarkModel::GetNodesByURL(const GURL& url,
-                                  std::vector<BookmarkNode*>* nodes) {
+                                  std::vector<const BookmarkNode*>* nodes) {
   AutoLock url_lock(url_lock_);
   BookmarkNode tmp_node(url);
   NodesOrderedByURLSet::iterator i = nodes_ordered_by_url_set_.find(&tmp_node);
@@ -232,8 +240,9 @@ void BookmarkModel::GetNodesByURL(const GURL& url,
   }
 }
 
-BookmarkNode* BookmarkModel::GetMostRecentlyAddedNodeForURL(const GURL& url) {
-  std::vector<BookmarkNode*> nodes;
+const BookmarkNode* BookmarkModel::GetMostRecentlyAddedNodeForURL(
+    const GURL& url) {
+  std::vector<const BookmarkNode*> nodes;
   GetNodesByURL(url, &nodes);
   if (nodes.empty())
     return NULL;
@@ -247,7 +256,7 @@ void BookmarkModel::GetBookmarks(std::vector<GURL>* urls) {
   const GURL* last_url = NULL;
   for (NodesOrderedByURLSet::iterator i = nodes_ordered_by_url_set_.begin();
        i != nodes_ordered_by_url_set_.end(); ++i) {
-    const GURL* url = &((*i)->url_);
+    const GURL* url = &((*i)->GetURL());
     // Only add unique URLs.
     if (!last_url || *url != *last_url)
       urls->push_back(*url);
@@ -260,15 +269,14 @@ bool BookmarkModel::IsBookmarked(const GURL& url) {
   return IsBookmarkedNoLock(url);
 }
 
-BookmarkNode* BookmarkModel::GetNodeByID(int id) {
+const BookmarkNode* BookmarkModel::GetNodeByID(int id) {
   // TODO(sky): TreeNode needs a method that visits all nodes using a predicate.
   return GetNodeByID(&root_, id);
 }
 
-BookmarkNode* BookmarkModel::AddGroup(
-    BookmarkNode* parent,
-    int index,
-    const std::wstring& title) {
+const BookmarkNode* BookmarkModel::AddGroup(const BookmarkNode* parent,
+                                            int index,
+                                            const std::wstring& title) {
   if (!loaded_ || parent == &root_ || !IsValidIndex(parent, index, true)) {
     // Can't add to the root.
     NOTREACHED();
@@ -277,27 +285,27 @@ BookmarkNode* BookmarkModel::AddGroup(
 
   BookmarkNode* new_node = new BookmarkNode(generate_next_node_id(),
                                             GURL());
-  new_node->date_group_modified_ = Time::Now();
+  new_node->set_date_group_modified(Time::Now());
   new_node->SetTitle(title);
-  new_node->type_ = history::StarredEntry::USER_GROUP;
+  new_node->SetType(history::StarredEntry::USER_GROUP);
 
-  return AddNode(parent, index, new_node, false);
+  return AddNode(AsMutable(parent), index, new_node, false);
 }
 
-BookmarkNode* BookmarkModel::AddURL(BookmarkNode* parent,
-                                    int index,
-                                    const std::wstring& title,
-                                    const GURL& url) {
+const BookmarkNode* BookmarkModel::AddURL(const BookmarkNode* parent,
+                                          int index,
+                                          const std::wstring& title,
+                                          const GURL& url) {
   return AddURLWithCreationTime(parent, index, title, url, Time::Now());
 }
 
-BookmarkNode* BookmarkModel::AddURLWithCreationTime(
-    BookmarkNode* parent,
+const BookmarkNode* BookmarkModel::AddURLWithCreationTime(
+    const BookmarkNode* parent,
     int index,
     const std::wstring& title,
     const GURL& url,
     const Time& creation_time) {
-  if (!loaded_ || !url.is_valid() || parent == &root_ ||
+  if (!loaded_ || !url.is_valid() || is_root(parent) ||
       !IsValidIndex(parent, index, true)) {
     NOTREACHED();
     return NULL;
@@ -309,8 +317,8 @@ BookmarkNode* BookmarkModel::AddURLWithCreationTime(
 
   BookmarkNode* new_node = new BookmarkNode(generate_next_node_id(), url);
   new_node->SetTitle(title);
-  new_node->date_added_ = creation_time;
-  new_node->type_ = history::StarredEntry::URL;
+  new_node->set_date_added(creation_time);
+  new_node->SetType(history::StarredEntry::URL);
 
   {
     // Only hold the lock for the duration of the insert.
@@ -318,11 +326,11 @@ BookmarkNode* BookmarkModel::AddURLWithCreationTime(
     nodes_ordered_by_url_set_.insert(new_node);
   }
 
-  return AddNode(parent, index, new_node, was_bookmarked);
+  return AddNode(AsMutable(parent), index, new_node, was_bookmarked);
 }
 
-void BookmarkModel::SortChildren(BookmarkNode* parent) {
-  if (!parent || !parent->is_folder() || parent == root_node() ||
+void BookmarkModel::SortChildren(const BookmarkNode* parent) {
+  if (!parent || !parent->is_folder() || is_root(parent) ||
       parent->GetChildCount() <= 1) {
     return;
   }
@@ -334,7 +342,9 @@ void BookmarkModel::SortChildren(BookmarkNode* parent) {
           error));
   if (U_FAILURE(error))
     collator.reset(NULL);
-  std::sort(parent->children().begin(), parent->children().end(),
+  BookmarkNode* mutable_parent = AsMutable(parent);
+  std::sort(mutable_parent->children().begin(),
+            mutable_parent->children().end(),
             SortComparator(collator.get()));
 
   if (store_.get())
@@ -347,7 +357,7 @@ void BookmarkModel::SortChildren(BookmarkNode* parent) {
 void BookmarkModel::SetURLStarred(const GURL& url,
                                   const std::wstring& title,
                                   bool is_starred) {
-  std::vector<BookmarkNode*> bookmarks;
+  std::vector<const BookmarkNode*> bookmarks;
   GetNodesByURL(url, &bookmarks);
   bool bookmarks_exist = !bookmarks.empty();
   if (is_starred == bookmarks_exist)
@@ -355,18 +365,18 @@ void BookmarkModel::SetURLStarred(const GURL& url,
 
   if (is_starred) {
     // Create a bookmark.
-    BookmarkNode* parent = GetParentForNewNodes();
+    const BookmarkNode* parent = GetParentForNewNodes();
     AddURL(parent, parent->GetChildCount(), title, url);
   } else {
     // Remove all the bookmarks.
     for (size_t i = 0; i < bookmarks.size(); ++i) {
-      BookmarkNode* node = bookmarks[i];
+      const BookmarkNode* node = bookmarks[i];
       Remove(node->GetParent(), node->GetParent()->IndexOfChild(node));
     }
   }
 }
 
-void BookmarkModel::ResetDateGroupModified(BookmarkNode* node) {
+void BookmarkModel::ResetDateGroupModified(const BookmarkNode* node) {
   SetDateGroupModified(node, Time());
 }
 
@@ -404,7 +414,7 @@ bool BookmarkModel::IsBookmarkedNoLock(const GURL& url) {
           nodes_ordered_by_url_set_.end());
 }
 
-void BookmarkModel::FavIconLoaded(BookmarkNode* node) {
+void BookmarkModel::FavIconLoaded(const BookmarkNode* node) {
   // Send out notification to the observer.
   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
                     BookmarkNodeFavIconLoaded(this, node));
@@ -412,8 +422,7 @@ void BookmarkModel::FavIconLoaded(BookmarkNode* node) {
 
 void BookmarkModel::RemoveNode(BookmarkNode* node,
                                std::set<GURL>* removed_urls) {
-  if (!loaded_ || !node || node == &root_ || node == bookmark_bar_node_ ||
-      node == other_node_) {
+  if (!loaded_ || !node || is_permanent_node(node)) {
     NOTREACHED();
     return;
   }
@@ -486,7 +495,7 @@ void BookmarkModel::DoneLoading(
 void BookmarkModel::RemoveAndDeleteNode(BookmarkNode* delete_me) {
   scoped_ptr<BookmarkNode> node(delete_me);
 
-  BookmarkNode* parent = node->GetParent();
+  BookmarkNode* parent = AsMutable(node->GetParent());
   DCHECK(parent);
   int index = parent->IndexOfChild(node.get());
   parent->Remove(index);
@@ -564,19 +573,20 @@ void BookmarkModel::BlockTillLoaded() {
   loaded_signal_.Wait();
 }
 
-BookmarkNode* BookmarkModel::GetNodeByID(BookmarkNode* node, int id) {
+const BookmarkNode* BookmarkModel::GetNodeByID(const BookmarkNode* node,
+                                               int id) {
   if (node->id() == id)
     return node;
 
   for (int i = 0; i < node->GetChildCount(); ++i) {
-    BookmarkNode* result = GetNodeByID(node->GetChild(i), id);
+    const BookmarkNode* result = GetNodeByID(node->GetChild(i), id);
     if (result)
       return result;
   }
   return NULL;
 }
 
-bool BookmarkModel::IsValidIndex(BookmarkNode* parent,
+bool BookmarkModel::IsValidIndex(const BookmarkNode* parent,
                                  int index,
                                  bool allow_end) {
   return (parent && parent->is_folder() &&
@@ -584,10 +594,10 @@ bool BookmarkModel::IsValidIndex(BookmarkNode* parent,
                           (allow_end && index == parent->GetChildCount()))));
   }
 
-void BookmarkModel::SetDateGroupModified(BookmarkNode* parent,
+void BookmarkModel::SetDateGroupModified(const BookmarkNode* parent,
                                          const Time time) {
   DCHECK(parent);
-  parent->date_group_modified_ = time;
+  AsMutable(parent)->set_date_group_modified(time);
 
   if (store_.get())
     store_->ScheduleSave();
@@ -629,10 +639,10 @@ void BookmarkModel::OnFavIconDataAvailable(
       load_consumer_.GetClientData(
           profile_->GetHistoryService(Profile::EXPLICIT_ACCESS), handle);
   DCHECK(node);
-  node->favicon_load_handle_ = 0;
+  node->set_favicon_load_handle(0);
   if (know_favicon && data.get() &&
       PNGDecoder::Decode(&data->data, &fav_icon)) {
-    node->favicon_ = fav_icon;
+    node->set_favicon(fav_icon);
     FavIconLoaded(node);
   }
 }
@@ -651,16 +661,16 @@ void BookmarkModel::LoadFavIcon(BookmarkNode* node) {
       node->GetURL(), &load_consumer_,
       NewCallback(this, &BookmarkModel::OnFavIconDataAvailable));
   load_consumer_.SetClientData(history_service, handle, node);
-  node->favicon_load_handle_ = handle;
+  node->set_favicon_load_handle(handle);
 }
 
 void BookmarkModel::CancelPendingFavIconLoadRequests(BookmarkNode* node) {
-  if (node->favicon_load_handle_) {
+  if (node->favicon_load_handle()) {
     HistoryService* history =
         profile_->GetHistoryService(Profile::EXPLICIT_ACCESS);
     if (history)
-      history->CancelRequest(node->favicon_load_handle_);
-    node->favicon_load_handle_ = 0;
+      history->CancelRequest(node->favicon_load_handle());
+    node->set_favicon_load_handle(0);
   }
 }
 
@@ -673,11 +683,11 @@ void BookmarkModel::Observe(NotificationType type,
       Details<history::FavIconChangeDetails> favicon_details(details);
       for (std::set<GURL>::const_iterator i = favicon_details->urls.begin();
            i != favicon_details->urls.end(); ++i) {
-        std::vector<BookmarkNode*> nodes;
+        std::vector<const BookmarkNode*> nodes;
         GetNodesByURL(*i, &nodes);
         for (size_t i = 0; i < nodes.size(); ++i) {
           // Got an updated favicon, for a URL, do a new request.
-          BookmarkNode* node = nodes[i];
+          BookmarkNode* node = AsMutable(nodes[i]);
           node->InvalidateFavicon();
           CancelPendingFavIconLoadRequests(node);
           FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
diff --git a/chrome/browser/bookmarks/bookmark_model.h b/chrome/browser/bookmarks/bookmark_model.h
index d00e7c6..19b0ed0 100644
--- a/chrome/browser/bookmarks/bookmark_model.h
+++ b/chrome/browser/bookmarks/bookmark_model.h
@@ -42,18 +42,12 @@ class StarredURLDatabase;
 //
 class BookmarkNode : public TreeNode<BookmarkNode> {
   friend class BookmarkModel;
-  friend class BookmarkCodec;
-  friend class history::StarredURLDatabase;
-  FRIEND_TEST(BookmarkCodecTest, PersistIDsTest);
-  FRIEND_TEST(BookmarkEditorViewTest, ChangeParentAndURL);
-  FRIEND_TEST(BookmarkEditorViewTest, EditURLKeepsPosition);
-  FRIEND_TEST(BookmarkMenuBridgeTest, TestAddNodeToMenu);
-  FRIEND_TEST(BookmarkEditorGtkTest, ChangeParentAndURL);
-  FRIEND_TEST(BookmarkEditorGtkTest, EditURLKeepsPosition);
-  FRIEND_TEST(BookmarkModelTest, MostRecentlyAddedEntries);
-  FRIEND_TEST(BookmarkModelTest, GetMostRecentlyAddedNodeForURL);
 
  public:
+  // Creates a new node with the specified url and id of 0
+  explicit BookmarkNode(const GURL& url);
+  // Creates a new node with the specified url and id.
+  BookmarkNode(int id, const GURL& url);
   virtual ~BookmarkNode() {}
 
   // Returns the URL.
@@ -64,25 +58,25 @@ class BookmarkNode : public TreeNode<BookmarkNode> {
   // NOTE: this id is only unique for the session and NOT unique across
   // sessions. Don't persist it!
   int id() const { return id_; }
+  // Sets the id to the given value.
+  void set_id(int id) { id_ = id; }
 
   // Returns the type of this node.
   history::StarredEntry::Type GetType() const { return type_; }
-
-  // Called when the favicon becomes invalid.
-  void InvalidateFavicon() {
-    loaded_favicon_ = false;
-    favicon_ = SkBitmap();
-  }
+  void SetType(history::StarredEntry::Type type) { type_ = type; }
 
   // Returns the time the bookmark/group was added.
-  base::Time date_added() const { return date_added_; }
-
+  const base::Time& date_added() const { return date_added_; }
   // Sets the time the bookmark/group was added.
   void set_date_added(const base::Time& date) { date_added_ = date; }
 
   // Returns the last time the group was modified. This is only maintained
   // for folders (including the bookmark and other folder).
-  base::Time date_group_modified() const { return date_group_modified_; }
+  const base::Time& date_group_modified() const { return date_group_modified_; }
+  // Sets the last time the group was modified.
+  void set_date_group_modified(const base::Time& date) {
+    date_group_modified_ = date;
+  }
 
   // Convenience for testing if this nodes represents a group. A group is
   // a node whose type is not URL.
@@ -91,27 +85,42 @@ class BookmarkNode : public TreeNode<BookmarkNode> {
   // Is this a URL?
   bool is_url() const { return type_ == history::StarredEntry::URL; }
 
-  // TODO(sky): Consider adding last visit time here, it'll greatly simplify
-  // HistoryContentsProvider.
+  // Returns the favicon. In nearly all cases you should use the method
+  // BookmarkModel::GetFavicon rather than this. BookmarkModel::GetFavicon
+  // takes care of loading the favicon if it isn't already loaded, where as
+  // this does not.
+  const SkBitmap& favicon() const { return favicon_; }
+  void set_favicon(const SkBitmap& icon) { favicon_ = icon; }
 
- private:
-  // Creates a new node with the specified url and id of 0
-  explicit BookmarkNode(const GURL& url);
-  // Creates a new node with the specified url and id.
-  BookmarkNode(int id, const GURL& url);
+  // The following methods are used by the bookmark model, and are not
+  // really useful outside of it.
 
-  // Returns the favicon for the this node. If the favicon has not yet been
-  // loaded it is loaded and the observer of the model notified when done.
-  const SkBitmap& favicon() const { return favicon_; }
+  bool is_favicon_loaded() const { return loaded_favicon_; }
+  void set_favicon_loaded(bool value) { loaded_favicon_ = value; }
 
-  // helper to initialize various fields during construction.
-  void Initialize(int id);
+  HistoryService::Handle favicon_load_handle() const {
+    return favicon_load_handle_;
+  }
+  void set_favicon_load_handle(HistoryService::Handle handle) {
+    favicon_load_handle_ = handle;
+  }
+
+  // Called when the favicon becomes invalid.
+  void InvalidateFavicon() {
+    loaded_favicon_ = false;
+    favicon_ = SkBitmap();
+  }
 
   // Resets the properties of the node from the supplied entry.
+  // This is used by the bookmark model and not really useful outside of it.
   void Reset(const history::StarredEntry& entry);
 
-  // Sets the id to the given value.
-  void set_id(int id) { id_ = id; }
+  // TODO(sky): Consider adding last visit time here, it'll greatly simplify
+  // HistoryContentsProvider.
+
+ private:
+  // helper to initialize various fields during construction.
+  void Initialize(int id);
 
   // Unique identifier for this node.
   int id_;
@@ -157,40 +166,40 @@ class BookmarkModelObserver {
 
   // Invoked when a node has moved.
   virtual void BookmarkNodeMoved(BookmarkModel* model,
-                                 BookmarkNode* old_parent,
+                                 const BookmarkNode* old_parent,
                                  int old_index,
-                                 BookmarkNode* new_parent,
+                                 const BookmarkNode* new_parent,
                                  int new_index) = 0;
 
   // Invoked when a node has been added.
   virtual void BookmarkNodeAdded(BookmarkModel* model,
-                                 BookmarkNode* parent,
+                                 const BookmarkNode* parent,
                                  int index) = 0;
 
   // Invoked when a node has been removed, the item may still be starred though.
   // TODO(sky): merge these two into one.
   virtual void BookmarkNodeRemoved(BookmarkModel* model,
-                                   BookmarkNode* parent,
+                                   const BookmarkNode* parent,
                                    int index) {}
   virtual void BookmarkNodeRemoved(BookmarkModel* model,
-                                   BookmarkNode* parent,
+                                   const BookmarkNode* parent,
                                    int old_index,
-                                   BookmarkNode* node) {
+                                   const BookmarkNode* node) {
     BookmarkNodeRemoved(model, parent, old_index);
   }
 
   // Invoked when the title or favicon of a node has changed.
   virtual void BookmarkNodeChanged(BookmarkModel* model,
-                                   BookmarkNode* node) = 0;
+                                   const BookmarkNode* node) = 0;
 
   // Invoked when a favicon has finished loading.
   virtual void BookmarkNodeFavIconLoaded(BookmarkModel* model,
-                                         BookmarkNode* node) = 0;
+                                         const BookmarkNode* node) = 0;
 
   // Invoked when the children (just direct children, not descendants) of
   // |node| have been reordered in some way, such as sorted.
   virtual void BookmarkNodeChildrenReordered(BookmarkModel* model,
-                                             BookmarkNode* node) = 0;
+                                             const BookmarkNode* node) = 0;
 };
 
 // BookmarkModel --------------------------------------------------------------
@@ -219,17 +228,17 @@ class BookmarkModel : public NotificationObserver, public BookmarkService {
 
   // Returns the root node. The bookmark bar node and other node are children of
   // the root node.
-  BookmarkNode* root_node() { return &root_; }
+  const BookmarkNode* root_node() { return &root_; }
 
   // Returns the bookmark bar node. This is NULL until loaded.
-  BookmarkNode* GetBookmarkBarNode() { return bookmark_bar_node_; }
+  const BookmarkNode* GetBookmarkBarNode() { return bookmark_bar_node_; }
 
   // Returns the 'other' node. This is NULL until loaded.
-  BookmarkNode* other_node() { return other_node_; }
+  const BookmarkNode* other_node() { return other_node_; }
 
   // Returns the parent the last node was added to. This never returns NULL
   // (as long as the model is loaded).
-  BookmarkNode* GetParentForNewNodes();
+  const BookmarkNode* GetParentForNewNodes();
 
   void AddObserver(BookmarkModelObserver* observer) {
     observers_.AddObserver(observer);
@@ -241,27 +250,29 @@ class BookmarkModel : public NotificationObserver, public BookmarkService {
 
   // Unstars or deletes the specified entry. Removing a group entry recursively
   // unstars all nodes. Observers are notified immediately.
-  void Remove(BookmarkNode* parent, int index);
+  void Remove(const BookmarkNode* parent, int index);
 
   // Moves the specified entry to a new location.
-  void Move(BookmarkNode* node, BookmarkNode* new_parent, int index);
+  void Move(const BookmarkNode* node,
+            const BookmarkNode* new_parent,
+            int index);
 
   // Returns the favicon for |node|. If the favicon has not yet been
   // loaded it is loaded and the observer of the model notified when done.
-  const SkBitmap& GetFavIcon(BookmarkNode* node);
+  const SkBitmap& GetFavIcon(const BookmarkNode* node);
 
   // Sets the title of the specified node.
-  void SetTitle(BookmarkNode* node, const std::wstring& title);
+  void SetTitle(const BookmarkNode* node, const std::wstring& title);
 
   // Returns true if the model finished loading.
   bool IsLoaded() { return loaded_; }
 
   // Returns the set of nodes with the specified URL.
-  void GetNodesByURL(const GURL& url, std::vector<BookmarkNode*>* nodes);
+  void GetNodesByURL(const GURL& url, std::vector<const BookmarkNode*>* nodes);
 
   // Returns the most recently added node for the url. Returns NULL if url is
   // not bookmarked.
-  BookmarkNode* GetMostRecentlyAddedNodeForURL(const GURL& url);
+  const BookmarkNode* GetMostRecentlyAddedNodeForURL(const GURL& url);
 
   // Returns all the bookmarked urls. This method is thread safe.
   virtual void GetBookmarks(std::vector<GURL>* urls);
@@ -276,29 +287,29 @@ class BookmarkModel : public NotificationObserver, public BookmarkService {
 
   // Returns the node with the specified id, or NULL if there is no node with
   // the specified id.
-  BookmarkNode* GetNodeByID(int id);
+  const BookmarkNode* GetNodeByID(int id);
 
   // Adds a new group node at the specified position.
-  BookmarkNode* AddGroup(BookmarkNode* parent,
-                         int index,
-                         const std::wstring& title);
+  const BookmarkNode* AddGroup(const BookmarkNode* parent,
+                               int index,
+                               const std::wstring& title);
 
   // Adds a url at the specified position.
-  BookmarkNode* AddURL(BookmarkNode* parent,
-                       int index,
-                       const std::wstring& title,
-                       const GURL& url);
+  const BookmarkNode* AddURL(const BookmarkNode* parent,
+                             int index,
+                             const std::wstring& title,
+                             const GURL& url);
 
   // Adds a url with a specific creation date.
-  BookmarkNode* AddURLWithCreationTime(BookmarkNode* parent,
-                                       int index,
-                                       const std::wstring& title,
-                                       const GURL& url,
-                                       const base::Time& creation_time);
+  const BookmarkNode* AddURLWithCreationTime(const BookmarkNode* parent,
+                                             int index,
+                                             const std::wstring& title,
+                                             const GURL& url,
+                                             const base::Time& creation_time);
 
   // Sorts the children of |parent|, notifying observers by way of the
   // BookmarkNodeChildrenReordered method.
-  void SortChildren(BookmarkNode* parent);
+  void SortChildren(const BookmarkNode* parent);
 
   // This is the convenience that makes sure the url is starred or not starred.
   // If is_starred is false, all bookmarks for URL are removed. If is_starred is
@@ -310,7 +321,7 @@ class BookmarkModel : public NotificationObserver, public BookmarkService {
   // Resets the 'date modified' time of the node to 0. This is used during
   // importing to exclude the newly created groups from showing up in the
   // combobox of most recently modified groups.
-  void ResetDateGroupModified(BookmarkNode* node);
+  void ResetDateGroupModified(const BookmarkNode* node);
 
   void GetBookmarksWithTitlesMatching(
       const std::wstring& text,
@@ -319,6 +330,21 @@ class BookmarkModel : public NotificationObserver, public BookmarkService {
 
   Profile* profile() const { return profile_; }
 
+  bool is_root(const BookmarkNode* node) const { return node == &root_; }
+  bool is_bookmark_bar_node(const BookmarkNode* node) const {
+    return node == bookmark_bar_node_;
+  }
+  bool is_other_bookmarks_node(const BookmarkNode* node) const {
+    return node == other_node_;
+  }
+  // Returns whether the given node is one of the permanent nodes - root node,
+  // bookmark bar node or other bookmarks node.
+  bool is_permanent_node(const BookmarkNode* node) const {
+    return is_root(node) ||
+           is_bookmark_bar_node(node) ||
+           is_other_bookmarks_node(node);
+  }
+
   // Sets the store to NULL, making it so the BookmarkModel does not persist
   // any changes to disk. This is only useful during testing to speed up
   // testing.
@@ -335,7 +361,7 @@ class BookmarkModel : public NotificationObserver, public BookmarkService {
   // Used to order BookmarkNodes by URL.
   class NodeURLComparator {
    public:
-    bool operator()(BookmarkNode* n1, BookmarkNode* n2) const {
+    bool operator()(const BookmarkNode* n1, const BookmarkNode* n2) const {
       return n1->GetURL() < n2->GetURL();
     }
   };
@@ -345,7 +371,7 @@ class BookmarkModel : public NotificationObserver, public BookmarkService {
   bool IsBookmarkedNoLock(const GURL& url);
 
   // Overriden to notify the observer the favicon has been loaded.
-  void FavIconLoaded(BookmarkNode* node);
+  void FavIconLoaded(const BookmarkNode* node);
 
   // Removes the node from internal maps and recurses through all children. If
   // the node is a url, its url is added to removed_urls.
@@ -373,13 +399,13 @@ class BookmarkModel : public NotificationObserver, public BookmarkService {
                         bool was_bookmarked);
 
   // Implementation of GetNodeByID.
-  BookmarkNode* GetNodeByID(BookmarkNode* node, int id);
+  const BookmarkNode* GetNodeByID(const BookmarkNode* node, int id);
 
   // Returns true if the parent and index are valid.
-  bool IsValidIndex(BookmarkNode* parent, int index, bool allow_end);
+  bool IsValidIndex(const BookmarkNode* parent, int index, bool allow_end);
 
   // Sets the date modified time of the specified node.
-  void SetDateGroupModified(BookmarkNode* parent, const base::Time time);
+  void SetDateGroupModified(const BookmarkNode* parent, const base::Time time);
 
   // Creates the bookmark bar/other nodes. These call into
   // CreateRootNodeFromStarredEntry.
diff --git a/chrome/browser/bookmarks/bookmark_model_test_utils.cc b/chrome/browser/bookmarks/bookmark_model_test_utils.cc
index 004bf51..e8e9d40 100644
--- a/chrome/browser/bookmarks/bookmark_model_test_utils.cc
+++ b/chrome/browser/bookmarks/bookmark_model_test_utils.cc
@@ -8,8 +8,8 @@
 #include "testing/gtest/include/gtest/gtest.h"
 
 // static
-void BookmarkModelTestUtils::AssertNodesEqual(BookmarkNode* expected,
-                                              BookmarkNode* actual,
+void BookmarkModelTestUtils::AssertNodesEqual(const BookmarkNode* expected,
+                                              const BookmarkNode* actual,
                                               bool check_ids) {
   ASSERT_TRUE(expected);
   ASSERT_TRUE(actual);
diff --git a/chrome/browser/bookmarks/bookmark_model_test_utils.h b/chrome/browser/bookmarks/bookmark_model_test_utils.h
index fbd814f..e942bd6 100644
--- a/chrome/browser/bookmarks/bookmark_model_test_utils.h
+++ b/chrome/browser/bookmarks/bookmark_model_test_utils.h
@@ -19,8 +19,8 @@ class BookmarkModelTestUtils {
  private:
   // Helper to verify the two given bookmark nodes.
   // The IDs of the bookmark nodes are compared only if check_ids is true.
-  static void AssertNodesEqual(BookmarkNode* expected,
-                               BookmarkNode* actual,
+  static void AssertNodesEqual(const BookmarkNode* expected,
+                               const BookmarkNode* actual,
                                bool check_ids);
 };
 
diff --git a/chrome/browser/bookmarks/bookmark_model_unittest.cc b/chrome/browser/bookmarks/bookmark_model_unittest.cc
index 5fe296f..fc9fe0b 100644
--- a/chrome/browser/bookmarks/bookmark_model_unittest.cc
+++ b/chrome/browser/bookmarks/bookmark_model_unittest.cc
@@ -19,6 +19,21 @@
 using base::Time;
 using base::TimeDelta;
 
+namespace {
+
+// Helper to get a mutable bookmark node.
+static BookmarkNode* AsMutable(const BookmarkNode* node) {
+  return const_cast<BookmarkNode*>(node);
+}
+
+void SwapDateAdded(BookmarkNode* n1, BookmarkNode* n2) {
+  Time tmp = n1->date_added();
+  n1->set_date_added(n2->date_added());
+  n2->set_date_added(tmp);
+}
+
+}  // anonymous namespace
+
 class BookmarkModelTest : public testing::Test, public BookmarkModelObserver {
  public:
   struct ObserverDetails {
@@ -26,8 +41,8 @@ class BookmarkModelTest : public testing::Test, public BookmarkModelObserver {
       Set(NULL, NULL, -1, -1);
     }
 
-    void Set(BookmarkNode* node1,
-             BookmarkNode* node2,
+    void Set(const BookmarkNode* node1,
+             const BookmarkNode* node2,
              int index1,
              int index2) {
       this->node1 = node1;
@@ -36,8 +51,8 @@ class BookmarkModelTest : public testing::Test, public BookmarkModelObserver {
       this->index2 = index2;
     }
 
-    void AssertEquals(BookmarkNode* node1,
-                      BookmarkNode* node2,
+    void AssertEquals(const BookmarkNode* node1,
+                      const BookmarkNode* node2,
                       int index1,
                       int index2) {
       ASSERT_TRUE(this->node1 == node1);
@@ -46,8 +61,8 @@ class BookmarkModelTest : public testing::Test, public BookmarkModelObserver {
       ASSERT_EQ(index2, this->index2);
     }
 
-    BookmarkNode* node1;
-    BookmarkNode* node2;
+    const BookmarkNode* node1;
+    const BookmarkNode* node2;
     int index1;
     int index2;
   };
@@ -64,41 +79,41 @@ class BookmarkModelTest : public testing::Test, public BookmarkModelObserver {
   }
 
   virtual void BookmarkNodeMoved(BookmarkModel* model,
-                                 BookmarkNode* old_parent,
+                                 const BookmarkNode* old_parent,
                                  int old_index,
-                                 BookmarkNode* new_parent,
+                                 const BookmarkNode* new_parent,
                                  int new_index) {
     moved_count++;
     observer_details.Set(old_parent, new_parent, old_index, new_index);
   }
 
   virtual void BookmarkNodeAdded(BookmarkModel* model,
-                                 BookmarkNode* parent,
+                                 const BookmarkNode* parent,
                                  int index) {
     added_count++;
     observer_details.Set(parent, NULL, index, -1);
   }
 
   virtual void BookmarkNodeRemoved(BookmarkModel* model,
-                                   BookmarkNode* parent,
+                                   const BookmarkNode* parent,
                                    int index) {
     removed_count++;
     observer_details.Set(parent, NULL, index, -1);
   }
 
   virtual void BookmarkNodeChanged(BookmarkModel* model,
-                                   BookmarkNode* node) {
+                                   const BookmarkNode* node) {
     changed_count++;
     observer_details.Set(node, NULL, -1, -1);
   }
 
   virtual void BookmarkNodeChildrenReordered(BookmarkModel* model,
-                                             BookmarkNode* node) {
+                                             const BookmarkNode* node) {
     reordered_count_++;
   }
 
   virtual void BookmarkNodeFavIconLoaded(BookmarkModel* model,
-                                         BookmarkNode* node) {
+                                         const BookmarkNode* node) {
     // We never attempt to load favicons, so that this method never
     // gets invoked.
   }
@@ -136,12 +151,12 @@ class BookmarkModelTest : public testing::Test, public BookmarkModelObserver {
 };
 
 TEST_F(BookmarkModelTest, InitialState) {
-  BookmarkNode* bb_node = model.GetBookmarkBarNode();
+  const BookmarkNode* bb_node = model.GetBookmarkBarNode();
   ASSERT_TRUE(bb_node != NULL);
   EXPECT_EQ(0, bb_node->GetChildCount());
   EXPECT_EQ(history::StarredEntry::BOOKMARK_BAR, bb_node->GetType());
 
-  BookmarkNode* other_node = model.other_node();
+  const BookmarkNode* other_node = model.other_node();
   ASSERT_TRUE(other_node != NULL);
   EXPECT_EQ(0, other_node->GetChildCount());
   EXPECT_EQ(history::StarredEntry::OTHER, other_node->GetType());
@@ -150,11 +165,11 @@ TEST_F(BookmarkModelTest, InitialState) {
 }
 
 TEST_F(BookmarkModelTest, AddURL) {
-  BookmarkNode* root = model.GetBookmarkBarNode();
+  const BookmarkNode* root = model.GetBookmarkBarNode();
   const std::wstring title(L"foo");
   const GURL url("http://foo.com");
 
-  BookmarkNode* new_node = model.AddURL(root, 0, title, url);
+  const BookmarkNode* new_node = model.AddURL(root, 0, title, url);
   AssertObserverCount(1, 0, 0, 0, 0);
   observer_details.AssertEquals(root, NULL, 0, -1);
 
@@ -169,10 +184,10 @@ TEST_F(BookmarkModelTest, AddURL) {
 }
 
 TEST_F(BookmarkModelTest, AddGroup) {
-  BookmarkNode* root = model.GetBookmarkBarNode();
+  const BookmarkNode* root = model.GetBookmarkBarNode();
   const std::wstring title(L"foo");
 
-  BookmarkNode* new_node = model.AddGroup(root, 0, title);
+  const BookmarkNode* new_node = model.AddGroup(root, 0, title);
   AssertObserverCount(1, 0, 0, 0, 0);
   observer_details.AssertEquals(root, NULL, 0, -1);
 
@@ -191,7 +206,7 @@ TEST_F(BookmarkModelTest, AddGroup) {
 }
 
 TEST_F(BookmarkModelTest, RemoveURL) {
-  BookmarkNode* root = model.GetBookmarkBarNode();
+  const BookmarkNode* root = model.GetBookmarkBarNode();
   const std::wstring title(L"foo");
   const GURL url("http://foo.com");
   model.AddURL(root, 0, title, url);
@@ -207,8 +222,8 @@ TEST_F(BookmarkModelTest, RemoveURL) {
 }
 
 TEST_F(BookmarkModelTest, RemoveGroup) {
-  BookmarkNode* root = model.GetBookmarkBarNode();
-  BookmarkNode* group = model.AddGroup(root, 0, L"foo");
+  const BookmarkNode* root = model.GetBookmarkBarNode();
+  const BookmarkNode* group = model.AddGroup(root, 0, L"foo");
 
   ClearCounts();
 
@@ -230,10 +245,10 @@ TEST_F(BookmarkModelTest, RemoveGroup) {
 }
 
 TEST_F(BookmarkModelTest, SetTitle) {
-  BookmarkNode* root = model.GetBookmarkBarNode();
+  const BookmarkNode* root = model.GetBookmarkBarNode();
   std::wstring title(L"foo");
   const GURL url("http://foo.com");
-  BookmarkNode* node = model.AddURL(root, 0, title, url);
+  const BookmarkNode* node = model.AddURL(root, 0, title, url);
 
   ClearCounts();
 
@@ -245,11 +260,11 @@ TEST_F(BookmarkModelTest, SetTitle) {
 }
 
 TEST_F(BookmarkModelTest, Move) {
-  BookmarkNode* root = model.GetBookmarkBarNode();
+  const BookmarkNode* root = model.GetBookmarkBarNode();
   std::wstring title(L"foo");
   const GURL url("http://foo.com");
-  BookmarkNode* node = model.AddURL(root, 0, title, url);
-  BookmarkNode* group1 = model.AddGroup(root, 0, L"foo");
+  const BookmarkNode* node = model.AddURL(root, 0, title, url);
+  const BookmarkNode* group1 = model.AddGroup(root, 0, L"foo");
   ClearCounts();
 
   model.Move(node, group1, 0);
@@ -285,12 +300,12 @@ TEST_F(BookmarkModelTest, ParentForNewNodes) {
 // Make sure recently modified stays in sync when adding a URL.
 TEST_F(BookmarkModelTest, MostRecentlyModifiedGroups) {
   // Add a group.
-  BookmarkNode* group = model.AddGroup(model.other_node(), 0, L"foo");
+  const BookmarkNode* group = model.AddGroup(model.other_node(), 0, L"foo");
   // Add a URL to it.
   model.AddURL(group, 0, L"blah", GURL("http://foo.com"));
 
   // Make sure group is in the most recently modified.
-  std::vector<BookmarkNode*> most_recent_groups =
+  std::vector<const BookmarkNode*> most_recent_groups =
       bookmark_utils::GetMostRecentlyModifiedGroups(&model, 1);
   ASSERT_EQ(1U, most_recent_groups.size());
   ASSERT_EQ(group, most_recent_groups[0]);
@@ -309,21 +324,29 @@ TEST_F(BookmarkModelTest, MostRecentlyAddedEntries) {
   // Add a couple of nodes such that the following holds for the time of the
   // nodes: n1 > n2 > n3 > n4.
   Time base_time = Time::Now();
-  BookmarkNode* n1 = model.AddURL(
-      model.GetBookmarkBarNode(), 0, L"blah", GURL("http://foo.com/0"));
-  BookmarkNode* n2 = model.AddURL(
-      model.GetBookmarkBarNode(), 1, L"blah", GURL("http://foo.com/1"));
-  BookmarkNode* n3 = model.AddURL(
-      model.GetBookmarkBarNode(), 2, L"blah", GURL("http://foo.com/2"));
-  BookmarkNode* n4 = model.AddURL(
-      model.GetBookmarkBarNode(), 3, L"blah", GURL("http://foo.com/3"));
-  n1->date_added_ = base_time + TimeDelta::FromDays(4);
-  n2->date_added_ = base_time + TimeDelta::FromDays(3);
-  n3->date_added_ = base_time + TimeDelta::FromDays(2);
-  n4->date_added_ = base_time + TimeDelta::FromDays(1);
+  BookmarkNode* n1 = AsMutable(model.AddURL(model.GetBookmarkBarNode(),
+                                  0,
+                                  L"blah",
+                                  GURL("http://foo.com/0")));
+  BookmarkNode* n2 = AsMutable(model.AddURL(model.GetBookmarkBarNode(),
+                                  1,
+                                  L"blah",
+                                  GURL("http://foo.com/1")));
+  BookmarkNode* n3 = AsMutable(model.AddURL(model.GetBookmarkBarNode(),
+                                  2,
+                                  L"blah",
+                                  GURL("http://foo.com/2")));
+  BookmarkNode* n4 = AsMutable(model.AddURL(model.GetBookmarkBarNode(),
+                                  3,
+                                  L"blah",
+                                  GURL("http://foo.com/3")));
+  n1->set_date_added(base_time + TimeDelta::FromDays(4));
+  n2->set_date_added(base_time + TimeDelta::FromDays(3));
+  n3->set_date_added(base_time + TimeDelta::FromDays(2));
+  n4->set_date_added(base_time + TimeDelta::FromDays(1));
 
   // Make sure order is honored.
-  std::vector<BookmarkNode*> recently_added;
+  std::vector<const BookmarkNode*> recently_added;
   bookmark_utils::GetMostRecentlyAddedEntries(&model, 2, &recently_added);
   ASSERT_EQ(2U, recently_added.size());
   ASSERT_TRUE(n1 == recently_added[0]);
@@ -331,7 +354,7 @@ TEST_F(BookmarkModelTest, MostRecentlyAddedEntries) {
 
   // swap 1 and 2, then check again.
   recently_added.clear();
-  std::swap(n1->date_added_, n2->date_added_);
+  SwapDateAdded(n1, n2);
   bookmark_utils::GetMostRecentlyAddedEntries(&model, 4, &recently_added);
   ASSERT_EQ(4U, recently_added.size());
   ASSERT_TRUE(n2 == recently_added[0]);
@@ -346,16 +369,18 @@ TEST_F(BookmarkModelTest, GetMostRecentlyAddedNodeForURL) {
   // nodes: n1 > n2
   Time base_time = Time::Now();
   const GURL url("http://foo.com/0");
-  BookmarkNode* n1 = model.AddURL(model.GetBookmarkBarNode(), 0, L"blah", url);
-  BookmarkNode* n2 = model.AddURL(model.GetBookmarkBarNode(), 1, L"blah", url);
-  n1->date_added_ = base_time + TimeDelta::FromDays(4);
-  n2->date_added_ = base_time + TimeDelta::FromDays(3);
+  BookmarkNode* n1 = AsMutable(model.AddURL(
+      model.GetBookmarkBarNode(), 0, L"blah", url));
+  BookmarkNode* n2 = AsMutable(model.AddURL(
+      model.GetBookmarkBarNode(), 1, L"blah", url));
+  n1->set_date_added(base_time + TimeDelta::FromDays(4));
+  n2->set_date_added(base_time + TimeDelta::FromDays(3));
 
   // Make sure order is honored.
   ASSERT_EQ(n1, model.GetMostRecentlyAddedNodeForURL(url));
 
   // swap 1 and 2, then check again.
-  std::swap(n1->date_added_, n2->date_added_);
+  SwapDateAdded(n1, n2);
   ASSERT_EQ(n2, model.GetMostRecentlyAddedNodeForURL(url));
 }
 
@@ -408,7 +433,8 @@ class StarredListener : public NotificationObserver {
 TEST_F(BookmarkModelTest, NotifyURLsStarred) {
   StarredListener listener;
   const GURL url("http://foo.com/0");
-  BookmarkNode* n1 = model.AddURL(model.GetBookmarkBarNode(), 0, L"blah", url);
+  const BookmarkNode* n1 = model.AddURL(
+      model.GetBookmarkBarNode(), 0, L"blah", url);
 
   // Starred notification should be sent.
   EXPECT_EQ(1, listener.notification_count_);
@@ -420,7 +446,8 @@ TEST_F(BookmarkModelTest, NotifyURLsStarred) {
 
   // Add another bookmark for the same URL. This should not send any
   // notification.
-  BookmarkNode* n2 = model.AddURL(model.GetBookmarkBarNode(), 1, L"blah", url);
+  const BookmarkNode* n2 = model.AddURL(
+      model.GetBookmarkBarNode(), 1, L"blah", url);
 
   EXPECT_EQ(0, listener.notification_count_);
 
@@ -512,11 +539,11 @@ static void PopulateNodeFromString(const std::wstring& description,
 // Populates the BookmarkNode with the children of parent.
 static void PopulateBookmarkNode(TestNode* parent,
                                  BookmarkModel* model,
-                                 BookmarkNode* bb_node) {
+                                 const BookmarkNode* bb_node) {
   for (int i = 0; i < parent->GetChildCount(); ++i) {
     TestNode* child = parent->GetChild(i);
     if (child->value == history::StarredEntry::USER_GROUP) {
-      BookmarkNode* new_bb_node =
+      const BookmarkNode* new_bb_node =
           model->AddGroup(bb_node, i, child->GetTitle());
       PopulateBookmarkNode(child, model, new_bb_node);
     } else {
@@ -545,11 +572,11 @@ class BookmarkModelTestWithProfile : public testing::Test,
  protected:
   // Verifies the contents of the bookmark bar node match the contents of the
   // TestNode.
-  void VerifyModelMatchesNode(TestNode* expected, BookmarkNode* actual) {
+  void VerifyModelMatchesNode(TestNode* expected, const BookmarkNode* actual) {
     ASSERT_EQ(expected->GetChildCount(), actual->GetChildCount());
     for (int i = 0; i < expected->GetChildCount(); ++i) {
       TestNode* expected_child = expected->GetChild(i);
-      BookmarkNode* actual_child = actual->GetChild(i);
+      const BookmarkNode* actual_child = actual->GetChild(i);
       ASSERT_EQ(expected_child->GetTitle(), actual_child->GetTitle());
       if (expected_child->value == history::StarredEntry::USER_GROUP) {
         ASSERT_TRUE(actual_child->GetType() ==
@@ -567,7 +594,7 @@ class BookmarkModelTestWithProfile : public testing::Test,
   }
 
   void VerifyNoDuplicateIDs(BookmarkModel* model) {
-    TreeNodeIterator<BookmarkNode> it(model->root_node());
+    TreeNodeIterator<const BookmarkNode> it(model->root_node());
     base::hash_set<int> ids;
     while (it.has_next())
       ASSERT_TRUE(ids.insert(it.Next()->id()).second);
@@ -605,22 +632,22 @@ class BookmarkModelTestWithProfile : public testing::Test,
     MessageLoop::current()->Quit();
   }
   virtual void BookmarkNodeMoved(BookmarkModel* model,
-                                 BookmarkNode* old_parent,
+                                 const BookmarkNode* old_parent,
                                  int old_index,
-                                 BookmarkNode* new_parent,
+                                 const BookmarkNode* new_parent,
                                  int new_index) {}
   virtual void BookmarkNodeAdded(BookmarkModel* model,
-                                 BookmarkNode* parent,
+                                 const BookmarkNode* parent,
                                  int index) {}
   virtual void BookmarkNodeRemoved(BookmarkModel* model,
-                                   BookmarkNode* parent,
+                                   const BookmarkNode* parent,
                                    int index) {}
   virtual void BookmarkNodeChanged(BookmarkModel* model,
-                                   BookmarkNode* node) {}
+                                   const BookmarkNode* node) {}
   virtual void BookmarkNodeChildrenReordered(BookmarkModel* model,
-                                             BookmarkNode* node) {}
+                                             const BookmarkNode* node) {}
   virtual void BookmarkNodeFavIconLoaded(BookmarkModel* model,
-                                         BookmarkNode* node) {}
+                                         const BookmarkNode* node) {}
 
   MessageLoopForUI message_loop_;
 };
@@ -691,10 +718,10 @@ class BookmarkModelTestWithProfile2 : public BookmarkModelTestWithProfile {
     // other
     //   OF1
     //   http://www.google.com/intl/en/about.html - About Google
-    BookmarkNode* bbn = bb_model_->GetBookmarkBarNode();
+    const BookmarkNode* bbn = bb_model_->GetBookmarkBarNode();
     ASSERT_EQ(2, bbn->GetChildCount());
 
-    BookmarkNode* child = bbn->GetChild(0);
+    const BookmarkNode* child = bbn->GetChild(0);
     ASSERT_EQ(history::StarredEntry::URL, child->GetType());
     ASSERT_EQ(L"Google", child->GetTitle());
     ASSERT_TRUE(child->GetURL() == GURL("http://www.google.com"));
@@ -704,7 +731,7 @@ class BookmarkModelTestWithProfile2 : public BookmarkModelTestWithProfile {
     ASSERT_EQ(L"F1", child->GetTitle());
     ASSERT_EQ(2, child->GetChildCount());
 
-    BookmarkNode* parent = child;
+    const BookmarkNode* parent = child;
     child = parent->GetChild(0);
     ASSERT_EQ(history::StarredEntry::URL, child->GetType());
     ASSERT_EQ(L"Google Advertising", child->GetTitle());
@@ -808,13 +835,15 @@ TEST_F(BookmarkModelTest, Sort) {
   // 'C' and 'a' are folders.
   TestNode bbn;
   PopulateNodeFromString(L"B [ a ] d [ a ]", &bbn);
-  BookmarkNode* parent = model.GetBookmarkBarNode();
+  const BookmarkNode* parent = model.GetBookmarkBarNode();
   PopulateBookmarkNode(&bbn, &model, parent);
 
-  parent->GetChild(1)->SetTitle(L"a");
-  delete parent->GetChild(1)->Remove(0);
-  parent->GetChild(3)->SetTitle(L"C");
-  delete parent->GetChild(3)->Remove(0);
+  BookmarkNode* child1 = AsMutable(parent->GetChild(1));
+  child1->SetTitle(L"a");
+  delete child1->Remove(0);
+  BookmarkNode* child3 = AsMutable(parent->GetChild(3));
+  child3->SetTitle(L"C");
+  delete child3->Remove(0);
 
   ClearCounts();
 
diff --git a/chrome/browser/bookmarks/bookmark_table_model.cc b/chrome/browser/bookmarks/bookmark_table_model.cc
index 733c99e..f8d8615 100644
--- a/chrome/browser/bookmarks/bookmark_table_model.cc
+++ b/chrome/browser/bookmarks/bookmark_table_model.cc
@@ -35,7 +35,7 @@ class VectorBackedBookmarkTableModel : public BookmarkTableModel {
       : BookmarkTableModel(model) {
   }
 
-  virtual BookmarkNode* GetNodeForRow(int row) {
+  virtual const BookmarkNode* GetNodeForRow(int row) {
     return nodes_[row];
   }
 
@@ -44,25 +44,25 @@ class VectorBackedBookmarkTableModel : public BookmarkTableModel {
   }
 
   virtual void BookmarkNodeMoved(BookmarkModel* model,
-                                 BookmarkNode* old_parent,
+                                 const BookmarkNode* old_parent,
                                  int old_index,
-                                 BookmarkNode* new_parent,
+                                 const BookmarkNode* new_parent,
                                  int new_index) {
     NotifyObserverOfChange(new_parent->GetChild(new_index));
   }
 
   virtual void BookmarkNodeFavIconLoaded(BookmarkModel* model,
-                                         BookmarkNode* node) {
+                                         const BookmarkNode* node) {
     NotifyObserverOfChange(node);
   }
 
   virtual void BookmarkNodeChanged(BookmarkModel* model,
-                                   BookmarkNode* node) {
+                                   const BookmarkNode* node) {
     NotifyObserverOfChange(node);
   }
 
  protected:
-  void NotifyObserverOfChange(BookmarkNode* node) {
+  void NotifyObserverOfChange(const BookmarkNode* node) {
     if (!observer())
       return;
 
@@ -71,7 +71,7 @@ class VectorBackedBookmarkTableModel : public BookmarkTableModel {
       observer()->OnItemsChanged(index, 1);
   }
 
-  typedef std::vector<BookmarkNode*> Nodes;
+  typedef std::vector<const BookmarkNode*> Nodes;
   Nodes& nodes() { return nodes_; }
 
  private:
@@ -88,16 +88,16 @@ class VectorBackedBookmarkTableModel : public BookmarkTableModel {
 // node is moved.
 class FolderBookmarkTableModel : public VectorBackedBookmarkTableModel {
  public:
-  FolderBookmarkTableModel(BookmarkModel* model, BookmarkNode* root_node)
+  FolderBookmarkTableModel(BookmarkModel* model, const BookmarkNode* root_node)
       : VectorBackedBookmarkTableModel(model),
         root_node_(root_node) {
     PopulateNodesFromRoot();
   }
 
   virtual void BookmarkNodeMoved(BookmarkModel* model,
-                                 BookmarkNode* old_parent,
+                                 const BookmarkNode* old_parent,
                                  int old_index,
-                                 BookmarkNode* new_parent,
+                                 const BookmarkNode* new_parent,
                                  int new_index) {
     if (old_parent == root_node_) {
       nodes().erase(nodes().begin() + old_index);
@@ -113,7 +113,7 @@ class FolderBookmarkTableModel : public VectorBackedBookmarkTableModel {
   }
 
   virtual void BookmarkNodeAdded(BookmarkModel* model,
-                                 BookmarkNode* parent,
+                                 const BookmarkNode* parent,
                                  int index) {
     if (root_node_ == parent) {
       nodes().insert(nodes().begin() + index, parent->GetChild(index));
@@ -123,9 +123,9 @@ class FolderBookmarkTableModel : public VectorBackedBookmarkTableModel {
   }
 
   virtual void BookmarkNodeRemoved(BookmarkModel* model,
-                                   BookmarkNode* parent,
+                                   const BookmarkNode* parent,
                                    int index,
-                                   BookmarkNode* node) {
+                                   const BookmarkNode* node) {
     if (root_node_->HasAncestor(node)) {
       // We, or one of our ancestors was removed.
       root_node_ = NULL;
@@ -142,17 +142,17 @@ class FolderBookmarkTableModel : public VectorBackedBookmarkTableModel {
   }
 
   virtual void BookmarkNodeChanged(BookmarkModel* model,
-                                   BookmarkNode* node) {
+                                   const BookmarkNode* node) {
     NotifyChanged(node);
   }
 
   virtual void BookmarkNodeFavIconLoaded(BookmarkModel* model,
-                                         BookmarkNode* node) {
+                                         const BookmarkNode* node) {
     NotifyChanged(node);
   }
 
   virtual void BookmarkNodeChildrenReordered(BookmarkModel* model,
-                                             BookmarkNode* node) {
+                                             const BookmarkNode* node) {
     if (node != root_node_)
       return;
 
@@ -164,7 +164,7 @@ class FolderBookmarkTableModel : public VectorBackedBookmarkTableModel {
   }
 
  private:
-  void NotifyChanged(BookmarkNode* node) {
+  void NotifyChanged(const BookmarkNode* node) {
     if (node->GetParent() == root_node_ && observer())
       observer()->OnItemsChanged(node->GetParent()->IndexOfChild(node), 1);
   }
@@ -176,7 +176,7 @@ class FolderBookmarkTableModel : public VectorBackedBookmarkTableModel {
 
   // The node we're showing the children of. This is set to NULL if the node
   // (or one of its ancestors) is removed from the model.
-  BookmarkNode* root_node_;
+  const BookmarkNode* root_node_;
 
   DISALLOW_COPY_AND_ASSIGN(FolderBookmarkTableModel);
 };
@@ -191,16 +191,16 @@ class RecentlyBookmarkedTableModel : public VectorBackedBookmarkTableModel {
   }
 
   virtual void BookmarkNodeAdded(BookmarkModel* model,
-                                 BookmarkNode* parent,
+                                 const BookmarkNode* parent,
                                  int index) {
     if (parent->GetChild(index)->is_url())
       UpdateRecentlyBookmarked();
   }
 
   virtual void BookmarkNodeRemoved(BookmarkModel* model,
-                                   BookmarkNode* parent,
+                                   const BookmarkNode* parent,
                                    int old_index,
-                                   BookmarkNode* old_node) {
+                                   const BookmarkNode* old_node) {
     if (old_node->is_url())
       UpdateRecentlyBookmarked();
   }
@@ -234,9 +234,9 @@ class BookmarkSearchTableModel : public VectorBackedBookmarkTableModel {
   }
 
   virtual void BookmarkNodeAdded(BookmarkModel* model,
-                                 BookmarkNode* parent,
+                                 const BookmarkNode* parent,
                                  int index) {
-    BookmarkNode* node = parent->GetChild(index);
+    const BookmarkNode* node = parent->GetChild(index);
     if (bookmark_utils::DoesBookmarkContainText(
         node, search_text_, languages_)) {
       nodes().push_back(node);
@@ -246,9 +246,9 @@ class BookmarkSearchTableModel : public VectorBackedBookmarkTableModel {
   }
 
   virtual void BookmarkNodeRemoved(BookmarkModel* model,
-                                   BookmarkNode* parent,
+                                   const BookmarkNode* parent,
                                    int index,
-                                   BookmarkNode* node) {
+                                   const BookmarkNode* node) {
     int internal_index = IndexOfNode(node);
     if (internal_index == -1)
       return;
@@ -277,7 +277,7 @@ BookmarkTableModel* BookmarkTableModel::CreateRecentlyBookmarkedModel(
 
 // static
 BookmarkTableModel* BookmarkTableModel::CreateBookmarkTableModelForFolder(
-    BookmarkModel* model, BookmarkNode* node) {
+    BookmarkModel* model, const BookmarkNode* node) {
   return new FolderBookmarkTableModel(model, node);
 }
 
@@ -301,7 +301,7 @@ BookmarkTableModel::~BookmarkTableModel() {
 }
 
 std::wstring BookmarkTableModel::GetText(int row, int column_id) {
-  BookmarkNode* node = GetNodeForRow(row);
+  const BookmarkNode* node = GetNodeForRow(row);
   switch (column_id) {
     case IDS_BOOKMARK_TABLE_TITLE: {
       std::wstring title = node->GetTitle();
@@ -368,7 +368,7 @@ SkBitmap BookmarkTableModel::GetIcon(int row) {
   static SkBitmap* default_icon = ResourceBundle::GetSharedInstance().
         GetBitmapNamed(IDR_DEFAULT_FAVICON);
 
-  BookmarkNode* node = GetNodeForRow(row);
+  const BookmarkNode* node = GetNodeForRow(row);
   if (node->is_folder())
     return *folder_icon;
 
@@ -383,7 +383,7 @@ void BookmarkTableModel::BookmarkModelBeingDeleted(BookmarkModel* model) {
   model_ = NULL;
 }
 
-int BookmarkTableModel::IndexOfNode(BookmarkNode* node) {
+int BookmarkTableModel::IndexOfNode(const BookmarkNode* node) {
   for (int i = RowCount() - 1; i >= 0; --i) {
     if (GetNodeForRow(i) == node)
       return i;
@@ -391,7 +391,8 @@ int BookmarkTableModel::IndexOfNode(BookmarkNode* node) {
   return -1;
 }
 
-void BookmarkTableModel::BuildPath(BookmarkNode* node, std::wstring* path) {
+void BookmarkTableModel::BuildPath(const BookmarkNode* node,
+                                   std::wstring* path) {
   if (!node) {
     NOTREACHED();
     return;
diff --git a/chrome/browser/bookmarks/bookmark_table_model.h b/chrome/browser/bookmarks/bookmark_table_model.h
index 7dd7f9e..997d7f0 100644
--- a/chrome/browser/bookmarks/bookmark_table_model.h
+++ b/chrome/browser/bookmarks/bookmark_table_model.h
@@ -24,7 +24,7 @@ class BookmarkTableModel : public TableModel,
   static BookmarkTableModel* CreateRecentlyBookmarkedModel(
       BookmarkModel* model);
   static BookmarkTableModel* CreateBookmarkTableModelForFolder(
-      BookmarkModel* model, BookmarkNode* node);
+      BookmarkModel* model, const BookmarkNode* node);
   static BookmarkTableModel* CreateSearchTableModel(
       BookmarkModel* model,
       const std::wstring& text,
@@ -44,15 +44,15 @@ class BookmarkTableModel : public TableModel,
   virtual void Loaded(BookmarkModel* model) {}
   virtual void BookmarkModelBeingDeleted(BookmarkModel* model);
   virtual void BookmarkNodeChildrenReordered(BookmarkModel* model,
-                                             BookmarkNode* node) {}
+                                             const BookmarkNode* node) {}
 
 
   // Returns the index of the specified node, or -1 if the node isn't in the
   // model.
-  virtual int IndexOfNode(BookmarkNode* node);
+  virtual int IndexOfNode(const BookmarkNode* node);
 
   // Returns the BookmarkNode at the specified index.
-  virtual BookmarkNode* GetNodeForRow(int row) = 0;
+  virtual const BookmarkNode* GetNodeForRow(int row) = 0;
 
   // Returns the underlying BookmarkModel.
   BookmarkModel* model() const { return model_; }
@@ -62,7 +62,7 @@ class BookmarkTableModel : public TableModel,
 
  private:
   // Builds the path shown in the path column for the specified node.
-  void BuildPath(BookmarkNode* node, std::wstring* path);
+  void BuildPath(const BookmarkNode* node, std::wstring* path);
 
   BookmarkModel* model_;
   TableModelObserver* observer_;
diff --git a/chrome/browser/bookmarks/bookmark_table_model_unittest.cc b/chrome/browser/bookmarks/bookmark_table_model_unittest.cc
index 9003256..39bc782 100644
--- a/chrome/browser/bookmarks/bookmark_table_model_unittest.cc
+++ b/chrome/browser/bookmarks/bookmark_table_model_unittest.cc
@@ -40,11 +40,11 @@ class BookmarkTableModelTest : public testing::Test,
     profile_->CreateBookmarkModel(true);
     // Populate with some default data.
     Time t0 = Time::Now();
-    BookmarkNode* bb = bookmark_model()->GetBookmarkBarNode();
+    const BookmarkNode* bb = bookmark_model()->GetBookmarkBarNode();
     bookmark_model()->AddURLWithCreationTime(bb, 0, L"a", url1_, t0);
     bookmark_model()->AddGroup(bb, 1, L"f1");
 
-    BookmarkNode* other = bookmark_model()->other_node();
+    const BookmarkNode* other = bookmark_model()->other_node();
     bookmark_model()->AddURLWithCreationTime(other, 0, L"b",
         url2_, t0 + TimeDelta::FromDays(2));
     bookmark_model()->AddGroup(other, 1, L"f2");
@@ -129,10 +129,10 @@ TEST_F(BookmarkTableModelTest, FolderInitialState) {
 
 // Verifies adding an item to folder model generates the correct event.
 TEST_F(BookmarkTableModelTest, AddToFolder) {
-  BookmarkNode* other = bookmark_model()->other_node();
+  const BookmarkNode* other = bookmark_model()->other_node();
   SetModel(BookmarkTableModel::CreateBookmarkTableModelForFolder(
       bookmark_model(), other));
-  BookmarkNode* new_node = bookmark_model()->AddURL(other, 0, L"new", url1_);
+  const BookmarkNode* new_node = bookmark_model()->AddURL(other, 0, L"new", url1_);
   // Should have gotten notification of the add.
   VerifyAndClearOberserverCounts(0, 0, 1, 0);
   ASSERT_EQ(4, model_->RowCount());
@@ -146,7 +146,7 @@ TEST_F(BookmarkTableModelTest, AddToFolder) {
 
 // Verifies sort sends out notification and results in a sort.
 TEST_F(BookmarkTableModelTest, SortFolder) {
-  BookmarkNode* other = bookmark_model()->other_node();
+  const BookmarkNode* other = bookmark_model()->other_node();
   SetModel(BookmarkTableModel::CreateBookmarkTableModelForFolder(
            bookmark_model(), other));
   ASSERT_EQ(3, model_->RowCount());
@@ -163,7 +163,7 @@ TEST_F(BookmarkTableModelTest, SortFolder) {
 
 // Verifies removing an item from folder model generates the correct event.
 TEST_F(BookmarkTableModelTest, RemoveFromFolder) {
-  BookmarkNode* other = bookmark_model()->other_node();
+  const BookmarkNode* other = bookmark_model()->other_node();
   SetModel(BookmarkTableModel::CreateBookmarkTableModelForFolder(
       bookmark_model(), other));
   bookmark_model()->Remove(other, 0);
@@ -179,7 +179,7 @@ TEST_F(BookmarkTableModelTest, RemoveFromFolder) {
 
 // Verifies changing an item in the folder model generates the correct event.
 TEST_F(BookmarkTableModelTest, ChangeFolder) {
-  BookmarkNode* other = bookmark_model()->other_node();
+  const BookmarkNode* other = bookmark_model()->other_node();
   SetModel(BookmarkTableModel::CreateBookmarkTableModelForFolder(
       bookmark_model(), other));
   bookmark_model()->SetTitle(other->GetChild(0), L"new");
@@ -199,8 +199,8 @@ TEST_F(BookmarkTableModelTest, RecentlyBookmarkedOrder) {
   SetModel(BookmarkTableModel::CreateRecentlyBookmarkedModel(bookmark_model()));
   EXPECT_EQ(3, model_->RowCount());
 
-  BookmarkNode* bb = bookmark_model()->GetBookmarkBarNode();
-  BookmarkNode* other = bookmark_model()->other_node();
+  const BookmarkNode* bb = bookmark_model()->GetBookmarkBarNode();
+  const BookmarkNode* other = bookmark_model()->other_node();
   EXPECT_TRUE(other->GetChild(0) == model_->GetNodeForRow(0));
   EXPECT_TRUE(other->GetChild(2) == model_->GetNodeForRow(1));
   EXPECT_TRUE(bb->GetChild(0) == model_->GetNodeForRow(2));
@@ -262,7 +262,7 @@ TEST_F(BookmarkTableModelTest, Search) {
 TEST_F(BookmarkTableModelTest, AddToSearch) {
   SetModel(BookmarkTableModel::CreateSearchTableModel(
       bookmark_model(), L"c", std::wstring()));
-  BookmarkNode* new_node =
+  const BookmarkNode* new_node =
       bookmark_model()->AddURL(bookmark_model()->other_node(), 0, L"c", url1_);
   // Should have gotten notification of the add.
   VerifyAndClearOberserverCounts(0, 0, 1, 0);
diff --git a/chrome/browser/bookmarks/bookmark_utils.cc b/chrome/browser/bookmarks/bookmark_utils.cc
index 88456c4..f7c18cf 100644
--- a/chrome/browser/bookmarks/bookmark_utils.cc
+++ b/chrome/browser/bookmarks/bookmark_utils.cc
@@ -76,23 +76,24 @@ class NewBrowserPageNavigator : public PageNavigator {
 
 void CloneDragDataImpl(BookmarkModel* model,
                        const BookmarkDragData::Element& element,
-                       BookmarkNode* parent,
+                       const BookmarkNode* parent,
                        int index_to_add_at) {
   if (element.is_url) {
     model->AddURL(parent, index_to_add_at, element.title, element.url);
   } else {
-    BookmarkNode* new_folder = model->AddGroup(parent, index_to_add_at,
-                                               element.title);
+    const BookmarkNode* new_folder = model->AddGroup(parent,
+                                                     index_to_add_at,
+                                                     element.title);
     for (int i = 0; i < static_cast<int>(element.children.size()); ++i)
       CloneDragDataImpl(model, element.children[i], new_folder, i);
   }
 }
 
 // Returns the number of descendants of node that are of type url.
-int DescendantURLCount(BookmarkNode* node) {
+int DescendantURLCount(const BookmarkNode* node) {
   int result = 0;
   for (int i = 0; i < node->GetChildCount(); ++i) {
-    BookmarkNode* child = node->GetChild(i);
+    const BookmarkNode* child = node->GetChild(i);
     if (child->is_url())
       result++;
     else
@@ -107,7 +108,7 @@ int DescendantURLCount(BookmarkNode* node) {
 // PageNavigator of the last active tab. This is done to handle a window
 // disposition of new window, in which case we want subsequent tabs to open in
 // that window.
-void OpenAllImpl(BookmarkNode* node,
+void OpenAllImpl(const BookmarkNode* node,
                  WindowOpenDisposition initial_disposition,
                  PageNavigator** navigator,
                  bool* opened_url) {
@@ -141,7 +142,7 @@ void OpenAllImpl(BookmarkNode* node,
 }
 
 bool ShouldOpenAll(gfx::NativeView parent,
-                   const std::vector<BookmarkNode*>& nodes) {
+                   const std::vector<const BookmarkNode*>& nodes) {
   int descendant_count = 0;
   for (size_t i = 0; i < nodes.size(); ++i)
     descendant_count += DescendantURLCount(nodes[i]);
@@ -163,7 +164,7 @@ bool ShouldOpenAll(gfx::NativeView parent,
 }
 
 // Comparison function that compares based on date modified of the two nodes.
-bool MoreRecentlyModified(BookmarkNode* n1, BookmarkNode* n2) {
+bool MoreRecentlyModified(const BookmarkNode* n1, const BookmarkNode* n2) {
   return n1->date_group_modified() > n2->date_group_modified();
 }
 
@@ -180,7 +181,7 @@ bool DoesBookmarkTextContainWords(const std::wstring& text,
 
 // Returns true if |node|s title or url contains the strings in |words|.
 // |languages| argument is user's accept-language setting to decode IDN.
-bool DoesBookmarkContainWords(BookmarkNode* node,
+bool DoesBookmarkContainWords(const BookmarkNode* node,
                               const std::vector<std::wstring>& words,
                               const std::wstring& languages) {
   return
@@ -210,7 +211,7 @@ int PreferredDropOperation(int source_operations, int operations) {
   return DragDropTypes::DRAG_NONE;
 }
 
-int BookmarkDragOperation(BookmarkNode* node) {
+int BookmarkDragOperation(const BookmarkNode* node) {
   if (node->is_url()) {
     return DragDropTypes::DRAG_COPY | DragDropTypes::DRAG_MOVE |
            DragDropTypes::DRAG_LINK;
@@ -221,7 +222,7 @@ int BookmarkDragOperation(BookmarkNode* node) {
 int BookmarkDropOperation(Profile* profile,
                           const views::DropTargetEvent& event,
                           const BookmarkDragData& data,
-                          BookmarkNode* parent,
+                          const BookmarkNode* parent,
                           int index) {
   if (data.IsFromProfile(profile) && data.size() > 1)
     // Currently only accept one dragged node at a time.
@@ -241,9 +242,9 @@ int BookmarkDropOperation(Profile* profile,
 
 int PerformBookmarkDrop(Profile* profile,
                         const BookmarkDragData& data,
-                        BookmarkNode* parent_node,
+                        const BookmarkNode* parent_node,
                         int index) {
-  BookmarkNode* dragged_node = data.GetFirstNode(profile);
+  const BookmarkNode* dragged_node = data.GetFirstNode(profile);
   BookmarkModel* model = profile->GetBookmarkModel();
   if (dragged_node) {
     // Drag from same profile, do a move.
@@ -269,7 +270,7 @@ int PerformBookmarkDrop(Profile* profile,
 
 bool IsValidDropLocation(Profile* profile,
                          const BookmarkDragData& data,
-                         BookmarkNode* drop_parent,
+                         const BookmarkNode* drop_parent,
                          int index) {
   if (!drop_parent->is_folder()) {
     NOTREACHED();
@@ -280,11 +281,11 @@ bool IsValidDropLocation(Profile* profile,
     return false;
 
   if (data.IsFromProfile(profile)) {
-    std::vector<BookmarkNode*> nodes = data.GetNodes(profile);
+    std::vector<const BookmarkNode*> nodes = data.GetNodes(profile);
     for (size_t i = 0; i < nodes.size(); ++i) {
       // Don't allow the drop if the user is attempting to drop on one of the
       // nodes being dragged.
-      BookmarkNode* node = nodes[i];
+      const BookmarkNode* node = nodes[i];
       int node_index = (drop_parent == node->GetParent()) ?
           drop_parent->IndexOfChild(nodes[i]) : -1;
       if (node_index != -1 && (index == node_index || index == node_index + 1))
@@ -302,7 +303,7 @@ bool IsValidDropLocation(Profile* profile,
 
 void CloneDragData(BookmarkModel* model,
                    const std::vector<BookmarkDragData::Element>& elements,
-                   BookmarkNode* parent,
+                   const BookmarkNode* parent,
                    int index_to_add_at) {
   if (!parent->is_folder() || !model) {
     NOTREACHED();
@@ -315,7 +316,7 @@ void CloneDragData(BookmarkModel* model,
 void OpenAll(gfx::NativeView parent,
              Profile* profile,
              PageNavigator* navigator,
-             const std::vector<BookmarkNode*>& nodes,
+             const std::vector<const BookmarkNode*>& nodes,
              WindowOpenDisposition initial_disposition) {
   if (!ShouldOpenAll(parent, nodes))
     return;
@@ -343,15 +344,15 @@ void OpenAll(gfx::NativeView parent,
 void OpenAll(gfx::NativeView parent,
              Profile* profile,
              PageNavigator* navigator,
-             BookmarkNode* node,
+             const BookmarkNode* node,
              WindowOpenDisposition initial_disposition) {
-  std::vector<BookmarkNode*> nodes;
+  std::vector<const BookmarkNode*> nodes;
   nodes.push_back(node);
   OpenAll(parent, profile, navigator, nodes, initial_disposition);
 }
 
 void CopyToClipboard(BookmarkModel* model,
-                     const std::vector<BookmarkNode*>& nodes,
+                     const std::vector<const BookmarkNode*>& nodes,
                      bool remove_nodes) {
   if (nodes.empty())
     return;
@@ -375,7 +376,7 @@ void CopyToClipboard(BookmarkModel* model,
 }
 
 void PasteFromClipboard(BookmarkModel* model,
-                        BookmarkNode* parent,
+                        const BookmarkNode* parent,
                         int index) {
   if (!parent)
     return;
@@ -398,7 +399,7 @@ void PasteFromClipboard(BookmarkModel* model,
 #endif
 }
 
-bool CanPasteFromClipboard(BookmarkNode* node) {
+bool CanPasteFromClipboard(const BookmarkNode* node) {
   if (!node)
     return false;
 
@@ -416,18 +417,18 @@ bool CanPasteFromClipboard(BookmarkNode* node) {
 #endif
 }
 
-std::vector<BookmarkNode*> GetMostRecentlyModifiedGroups(
+std::vector<const BookmarkNode*> GetMostRecentlyModifiedGroups(
     BookmarkModel* model,
     size_t max_count) {
-  std::vector<BookmarkNode*> nodes;
-  TreeNodeIterator<BookmarkNode> iterator(model->root_node());
+  std::vector<const BookmarkNode*> nodes;
+  TreeNodeIterator<const BookmarkNode> iterator(model->root_node());
   while (iterator.has_next()) {
-    BookmarkNode* parent = iterator.Next();
+    const BookmarkNode* parent = iterator.Next();
     if (parent->is_folder() && parent->date_group_modified() > base::Time()) {
       if (max_count == 0) {
         nodes.push_back(parent);
       } else {
-        std::vector<BookmarkNode*>::iterator i =
+        std::vector<const BookmarkNode*>::iterator i =
             std::upper_bound(nodes.begin(), nodes.end(), parent,
                              &MoreRecentlyModified);
         if (nodes.size() < max_count || i != nodes.end()) {
@@ -457,12 +458,12 @@ std::vector<BookmarkNode*> GetMostRecentlyModifiedGroups(
 
 void GetMostRecentlyAddedEntries(BookmarkModel* model,
                                  size_t count,
-                                 std::vector<BookmarkNode*>* nodes) {
-  TreeNodeIterator<BookmarkNode> iterator(model->root_node());
+                                 std::vector<const BookmarkNode*>* nodes) {
+  TreeNodeIterator<const BookmarkNode> iterator(model->root_node());
   while (iterator.has_next()) {
-    BookmarkNode* node = iterator.Next();
+    const BookmarkNode* node = iterator.Next();
     if (node->is_url()) {
-      std::vector<BookmarkNode*>::iterator insert_position =
+      std::vector<const BookmarkNode*>::iterator insert_position =
           std::upper_bound(nodes->begin(), nodes->end(), node,
                            &MoreRecentlyAdded);
       if (nodes->size() < count || insert_position != nodes->end()) {
@@ -474,7 +475,7 @@ void GetMostRecentlyAddedEntries(BookmarkModel* model,
   }
 }
 
-bool MoreRecentlyAdded(BookmarkNode* n1, BookmarkNode* n2) {
+bool MoreRecentlyAdded(const BookmarkNode* n1, const BookmarkNode* n2) {
   return n1->date_added() > n2->date_added();
 }
 
@@ -482,16 +483,16 @@ void GetBookmarksContainingText(BookmarkModel* model,
                                 const std::wstring& text,
                                 size_t max_count,
                                 const std::wstring& languages,
-                                std::vector<BookmarkNode*>* nodes) {
+                                std::vector<const BookmarkNode*>* nodes) {
   std::vector<std::wstring> words;
   QueryParser parser;
   parser.ExtractQueryWords(l10n_util::ToLower(text), &words);
   if (words.empty())
     return;
 
-  TreeNodeIterator<BookmarkNode> iterator(model->root_node());
+  TreeNodeIterator<const BookmarkNode> iterator(model->root_node());
   while (iterator.has_next()) {
-    BookmarkNode* node = iterator.Next();
+    const BookmarkNode* node = iterator.Next();
     if (node->is_url() && DoesBookmarkContainWords(node, words, languages)) {
       nodes->push_back(node);
       if (nodes->size() == max_count)
@@ -500,7 +501,7 @@ void GetBookmarksContainingText(BookmarkModel* model,
   }
 }
 
-bool DoesBookmarkContainText(BookmarkNode* node,
+bool DoesBookmarkContainText(const BookmarkNode* node,
                              const std::wstring& text,
                              const std::wstring& languages) {
   std::vector<std::wstring> words;
@@ -513,12 +514,12 @@ bool DoesBookmarkContainText(BookmarkNode* node,
 }
 
 void ApplyEditsWithNoGroupChange(BookmarkModel* model,
-                                 BookmarkNode* parent,
-                                 BookmarkNode* node,
+                                 const BookmarkNode* parent,
+                                 const BookmarkNode* node,
                                  const std::wstring& new_title,
                                  const GURL& new_url,
                                  BookmarkEditor::Handler* handler) {
-  BookmarkNode* old_parent = node ? node->GetParent() : NULL;
+  const BookmarkNode* old_parent = node ? node->GetParent() : NULL;
   const int old_index = old_parent ? old_parent->IndexOfChild(node) : -1;
 
   if (!node) {
@@ -546,12 +547,12 @@ void ApplyEditsWithNoGroupChange(BookmarkModel* model,
 }
 
 void ApplyEditsWithPossibleGroupChange(BookmarkModel* model,
-                                       BookmarkNode* new_parent,
-                                       BookmarkNode* node,
+                                       const BookmarkNode* new_parent,
+                                       const BookmarkNode* node,
                                        const std::wstring& new_title,
                                        const GURL& new_url,
                                        BookmarkEditor::Handler* handler) {
-  BookmarkNode* old_parent = node ? node->GetParent() : NULL;
+  const BookmarkNode* old_parent = node ? node->GetParent() : NULL;
   const int old_index = old_parent ? old_parent->IndexOfChild(node) : -1;
 
   if (node) {
@@ -560,19 +561,16 @@ void ApplyEditsWithPossibleGroupChange(BookmarkModel* model,
       // The parent is the same.
       if (new_url != node->GetURL()) {
         model->Remove(old_parent, old_index);
-        BookmarkNode* new_node =
-            model->AddURL(old_parent, old_index, new_title, new_url);
-        new_node->set_date_added(date_added);
+        model->AddURLWithCreationTime(old_parent, old_index,
+                                      new_title, new_url, date_added);
       } else {
         model->SetTitle(node, new_title);
       }
     } else if (new_url != node->GetURL()) {
       // The parent and URL changed.
       model->Remove(old_parent, old_index);
-      BookmarkNode* new_node =
-          model->AddURL(new_parent, new_parent->GetChildCount(), new_title,
-                        new_url);
-      new_node->set_date_added(date_added);
+      model->AddURLWithCreationTime(new_parent, new_parent->GetChildCount(),
+                                    new_title, new_url, date_added);
     } else {
       // The parent and title changed. Move the node and change the title.
       model->Move(node, new_parent, new_parent->GetChildCount());
diff --git a/chrome/browser/bookmarks/bookmark_utils.h b/chrome/browser/bookmarks/bookmark_utils.h
index 2a7cbda..a1a3e7b 100644
--- a/chrome/browser/bookmarks/bookmark_utils.h
+++ b/chrome/browser/bookmarks/bookmark_utils.h
@@ -33,7 +33,7 @@ namespace bookmark_utils {
 int PreferredDropOperation(int source_operations, int operations);
 
 // Returns the drag operations for the specified node.
-int BookmarkDragOperation(BookmarkNode* node);
+int BookmarkDragOperation(const BookmarkNode* node);
 
 // Returns the preferred drop operation on a bookmark menu/bar.
 // |parent| is the parent node the drop is to occur on and |index| the index the
@@ -41,14 +41,14 @@ int BookmarkDragOperation(BookmarkNode* node);
 int BookmarkDropOperation(Profile* profile,
                           const views::DropTargetEvent& event,
                           const BookmarkDragData& data,
-                          BookmarkNode* parent,
+                          const BookmarkNode* parent,
                           int index);
 
 // Performs a drop of bookmark data onto |parent_node| at |index|. Returns the
 // type of drop the resulted.
 int PerformBookmarkDrop(Profile* profile,
                         const BookmarkDragData& data,
-                        BookmarkNode* parent_node,
+                        const BookmarkNode* parent_node,
                         int index);
 
 // Returns true if the bookmark data can be dropped on |drop_parent| at
@@ -58,14 +58,14 @@ int PerformBookmarkDrop(Profile* profile,
 // a child of |drop_parent| at |index|.
 bool IsValidDropLocation(Profile* profile,
                          const BookmarkDragData& data,
-                         BookmarkNode* drop_parent,
+                         const BookmarkNode* drop_parent,
                          int index);
 
 // Clones drag data, adding newly created nodes to |parent| starting at
 // |index_to_add_at|.
 void CloneDragData(BookmarkModel* model,
                    const std::vector<BookmarkDragData::Element>& elements,
-                   BookmarkNode* parent,
+                   const BookmarkNode* parent,
                    int index_to_add_at);
 
 // Recursively opens all bookmarks. |initial_disposition| dictates how the
@@ -76,55 +76,55 @@ void CloneDragData(BookmarkModel* model,
 void OpenAll(gfx::NativeView parent,
              Profile* profile,
              PageNavigator* navigator,
-             const std::vector<BookmarkNode*>& nodes,
+             const std::vector<const BookmarkNode*>& nodes,
              WindowOpenDisposition initial_disposition);
 
 // Convenience for opening a single BookmarkNode.
 void OpenAll(gfx::NativeView parent,
              Profile* profile,
              PageNavigator* navigator,
-             BookmarkNode* node,
+             const BookmarkNode* node,
              WindowOpenDisposition initial_disposition);
 
 // Copies nodes onto the clipboard. If |remove_nodes| is true the nodes are
 // removed after copied to the clipboard. The nodes are copied in such a way
 // that if pasted again copies are made.
 void CopyToClipboard(BookmarkModel* model,
-                     const std::vector<BookmarkNode*>& nodes,
+                     const std::vector<const BookmarkNode*>& nodes,
                      bool remove_nodes);
 
 // Pastes from the clipboard. The new nodes are added to |parent|, unless
 // |parent| is null in which case this does nothing. The nodes are inserted
 // at |index|. If |index| is -1 the nodes are added to the end.
 void PasteFromClipboard(BookmarkModel* model,
-                        BookmarkNode* parent,
+                        const BookmarkNode* parent,
                         int index);
 
 // Returns true if the user can copy from the pasteboard.
-bool CanPasteFromClipboard(BookmarkNode* node);
+bool CanPasteFromClipboard(const BookmarkNode* node);
 
 // Returns a vector containing up to |max_count| of the most recently modified
 // groups. This never returns an empty vector.
-std::vector<BookmarkNode*> GetMostRecentlyModifiedGroups(BookmarkModel* model,
-                                                         size_t max_count);
+std::vector<const BookmarkNode*> GetMostRecentlyModifiedGroups(
+    BookmarkModel* model, size_t max_count);
 
 // Returns the most recently added bookmarks. This does not return groups,
 // only nodes of type url.
 void GetMostRecentlyAddedEntries(BookmarkModel* model,
                                  size_t count,
-                                 std::vector<BookmarkNode*>* nodes);
+                                 std::vector<const BookmarkNode*>* nodes);
 
 // Used by GetBookmarksMatchingText to return a matching node and the location
 // of the match in the title.
 struct TitleMatch {
-  BookmarkNode* node;
+  const BookmarkNode* node;
 
   // Location of the matching words in the title of the node.
   Snippet::MatchPositions match_positions;
 };
 
 // Returns true if |n1| was added more recently than |n2|.
-bool MoreRecentlyAdded(BookmarkNode* n1, BookmarkNode* n2);
+bool MoreRecentlyAdded(const BookmarkNode* n1, const BookmarkNode* n2);
 
 // Returns up to |max_count| bookmarks from |model| whose url or title contains
 // the text |text|.  |languages| is user's accept-language setting to decode
@@ -133,19 +133,19 @@ void GetBookmarksContainingText(BookmarkModel* model,
                                 const std::wstring& text,
                                 size_t max_count,
                                 const std::wstring& languages,
-                                std::vector<BookmarkNode*>* nodes);
+                                std::vector<const BookmarkNode*>* nodes);
 
 // Returns true if |node|'s url or title contains the string |text|.
 // |languages| is user's accept-language setting to decode IDN.
-bool DoesBookmarkContainText(BookmarkNode* node,
+bool DoesBookmarkContainText(const BookmarkNode* node,
                              const std::wstring& text,
                              const std::wstring& languages);
 
 // Modifies a bookmark node (assuming that there's no magic that needs to be
 // done regarding moving from one folder to another).
 void ApplyEditsWithNoGroupChange(BookmarkModel* model,
-                                 BookmarkNode* parent,
-                                 BookmarkNode* node,
+                                 const BookmarkNode* parent,
+                                 const BookmarkNode* node,
                                  const std::wstring& new_title,
                                  const GURL& new_url,
                                  BookmarkEditor::Handler* handler);
@@ -153,8 +153,8 @@ void ApplyEditsWithNoGroupChange(BookmarkModel* model,
 // Modifies a bookmark node assuming that the parent of the node may have
 // changed and the node will need to be removed and reinserted.
 void ApplyEditsWithPossibleGroupChange(BookmarkModel* model,
-                                       BookmarkNode* new_parent,
-                                       BookmarkNode* node,
+                                       const BookmarkNode* new_parent,
+                                       const BookmarkNode* node,
                                        const std::wstring& new_title,
                                        const GURL& new_url,
                                        BookmarkEditor::Handler* handler);
diff --git a/chrome/browser/bookmarks/bookmark_utils_unittest.cc b/chrome/browser/bookmarks/bookmark_utils_unittest.cc
index 2bd612f..e89ad8e 100644
--- a/chrome/browser/bookmarks/bookmark_utils_unittest.cc
+++ b/chrome/browser/bookmarks/bookmark_utils_unittest.cc
@@ -11,16 +11,16 @@ typedef testing::Test BookmarkUtilsTest;
 
 TEST_F(BookmarkUtilsTest, GetBookmarksContainingText) {
   BookmarkModel model(NULL);
-  BookmarkNode* n1 =
+  const BookmarkNode* n1 =
       model.AddURL(model.other_node(), 0, L"foo bar",
                    GURL("http://www.google.com"));
-  BookmarkNode* n2 =
+  const BookmarkNode* n2 =
       model.AddURL(model.other_node(), 0, L"baz buz",
                    GURL("http://www.cnn.com"));
 
   model.AddGroup(model.other_node(), 0, L"foo");
 
-  std::vector<BookmarkNode*> nodes;
+  std::vector<const BookmarkNode*> nodes;
   bookmark_utils::GetBookmarksContainingText(
       &model, L"foo", 100, std::wstring(), &nodes);
   ASSERT_EQ(1U, nodes.size());
@@ -48,8 +48,8 @@ TEST_F(BookmarkUtilsTest, GetBookmarksContainingText) {
 
 TEST_F(BookmarkUtilsTest, DoesBookmarkContainText) {
   BookmarkModel model(NULL);
-  BookmarkNode* node = model.AddURL(model.other_node(), 0, L"foo bar",
-                                    GURL("http://www.google.com"));
+  const BookmarkNode* node = model.AddURL(model.other_node(), 0, L"foo bar",
+                                          GURL("http://www.google.com"));
   // Matches to the title.
   ASSERT_TRUE(bookmark_utils::DoesBookmarkContainText(
       node, L"ar", std::wstring()));
diff --git a/chrome/browser/cocoa/bookmark_bar_bridge.h b/chrome/browser/cocoa/bookmark_bar_bridge.h
index 4d5c488..79805953 100644
--- a/chrome/browser/cocoa/bookmark_bar_bridge.h
+++ b/chrome/browser/cocoa/bookmark_bar_bridge.h
@@ -26,19 +26,19 @@ class BookmarkBarBridge : public BookmarkModelObserver {
   virtual void Loaded(BookmarkModel* model);
   virtual void BookmarkModelBeingDeleted(BookmarkModel* model);
   virtual void BookmarkNodeMoved(BookmarkModel* model,
-                                 BookmarkNode* old_parent,
+                                 const BookmarkNode* old_parent,
                                  int old_index,
-                                 BookmarkNode* new_parent,
+                                 const BookmarkNode* new_parent,
                                  int new_index);
   virtual void BookmarkNodeAdded(BookmarkModel* model,
-                                 BookmarkNode* parent,
+                                 const BookmarkNode* parent,
                                  int index);
   virtual void BookmarkNodeChanged(BookmarkModel* model,
-                                   BookmarkNode* node);
+                                   const BookmarkNode* node);
   virtual void BookmarkNodeFavIconLoaded(BookmarkModel* model,
-                                         BookmarkNode* node);
+                                         const BookmarkNode* node);
   virtual void BookmarkNodeChildrenReordered(BookmarkModel* model,
-                                             BookmarkNode* node);
+                                             const BookmarkNode* node);
 
  private:
   BookmarkBarController* controller_;  // weak; owns me
diff --git a/chrome/browser/cocoa/bookmark_bar_bridge.mm b/chrome/browser/cocoa/bookmark_bar_bridge.mm
index 54b3f5b..2263a3c 100644
--- a/chrome/browser/cocoa/bookmark_bar_bridge.mm
+++ b/chrome/browser/cocoa/bookmark_bar_bridge.mm
@@ -29,9 +29,9 @@ void BookmarkBarBridge::BookmarkModelBeingDeleted(BookmarkModel* model) {
 }
 
 void BookmarkBarBridge::BookmarkNodeMoved(BookmarkModel* model,
-                                          BookmarkNode* old_parent,
+                                          const BookmarkNode* old_parent,
                                           int old_index,
-                                          BookmarkNode* new_parent,
+                                          const BookmarkNode* new_parent,
                                           int new_index) {
   [controller_ nodeMoved:model
                oldParent:old_parent oldIndex:old_index
@@ -39,22 +39,22 @@ void BookmarkBarBridge::BookmarkNodeMoved(BookmarkModel* model,
 }
 
 void BookmarkBarBridge::BookmarkNodeAdded(BookmarkModel* model,
-                                          BookmarkNode* parent,
+                                          const BookmarkNode* parent,
                                           int index) {
   [controller_ nodeAdded:model parent:parent index:index];
 }
 
 void BookmarkBarBridge::BookmarkNodeChanged(BookmarkModel* model,
-                                            BookmarkNode* node) {
+                                            const BookmarkNode* node) {
   [controller_ nodeChanged:model node:node];
 }
 
 void BookmarkBarBridge::BookmarkNodeFavIconLoaded(BookmarkModel* model,
-                                                  BookmarkNode* node) {
+                                                  const BookmarkNode* node) {
   [controller_ nodeFavIconLoaded:model node:node];
 }
 
-void BookmarkBarBridge::BookmarkNodeChildrenReordered(BookmarkModel* model,
-                                                      BookmarkNode* node) {
+void BookmarkBarBridge::BookmarkNodeChildrenReordered(
+    BookmarkModel* model, const BookmarkNode* node) {
   [controller_ nodeChildrenReordered:model node:node];
 }
diff --git a/chrome/browser/cocoa/bookmark_bar_bridge_unittest.mm b/chrome/browser/cocoa/bookmark_bar_bridge_unittest.mm
index c5ac97b..2853cca 100644
--- a/chrome/browser/cocoa/bookmark_bar_bridge_unittest.mm
+++ b/chrome/browser/cocoa/bookmark_bar_bridge_unittest.mm
@@ -52,28 +52,28 @@ typedef std::pair<GURL,WindowOpenDisposition> OpenInfo;
 }
 
 - (void)nodeMoved:(BookmarkModel*)model
-        oldParent:(BookmarkNode*)oldParent oldIndex:(int)oldIndex
-        newParent:(BookmarkNode*)newParent newIndex:(int)newIndex {
+        oldParent:(const BookmarkNode*)oldParent oldIndex:(int)oldIndex
+        newParent:(const BookmarkNode*)newParent newIndex:(int)newIndex {
   [callbacks_ addObject:[NSNumber numberWithInt:2]];
 }
 
 - (void)nodeAdded:(BookmarkModel*)model
-           parent:(BookmarkNode*)oldParent index:(int)index {
+           parent:(const BookmarkNode*)oldParent index:(int)index {
   [callbacks_ addObject:[NSNumber numberWithInt:3]];
 }
 
 - (void)nodeChanged:(BookmarkModel*)model
-               node:(BookmarkNode*)node {
+               node:(const BookmarkNode*)node {
   [callbacks_ addObject:[NSNumber numberWithInt:4]];
 }
 
 - (void)nodeFavIconLoaded:(BookmarkModel*)model
-                     node:(BookmarkNode*)node {
+                     node:(const BookmarkNode*)node {
   [callbacks_ addObject:[NSNumber numberWithInt:5]];
 }
 
 - (void)nodeChildrenReordered:(BookmarkModel*)model
-                         node:(BookmarkNode*)node {
+                         node:(const BookmarkNode*)node {
   [callbacks_ addObject:[NSNumber numberWithInt:6]];
 }
 
diff --git a/chrome/browser/cocoa/bookmark_bar_controller.h b/chrome/browser/cocoa/bookmark_bar_controller.h
index ca9dc0f..87ac43e 100644
--- a/chrome/browser/cocoa/bookmark_bar_controller.h
+++ b/chrome/browser/cocoa/bookmark_bar_controller.h
@@ -78,16 +78,16 @@ class Profile;
 - (void)loaded:(BookmarkModel*)model;
 - (void)beingDeleted:(BookmarkModel*)model;
 - (void)nodeMoved:(BookmarkModel*)model
-        oldParent:(BookmarkNode*)oldParent oldIndex:(int)oldIndex
-        newParent:(BookmarkNode*)newParent newIndex:(int)newIndex;
+        oldParent:(const BookmarkNode*)oldParent oldIndex:(int)oldIndex
+        newParent:(const BookmarkNode*)newParent newIndex:(int)newIndex;
 - (void)nodeAdded:(BookmarkModel*)model
-           parent:(BookmarkNode*)oldParent index:(int)index;
+           parent:(const BookmarkNode*)oldParent index:(int)index;
 - (void)nodeChanged:(BookmarkModel*)model
-               node:(BookmarkNode*)node;
+               node:(const BookmarkNode*)node;
 - (void)nodeFavIconLoaded:(BookmarkModel*)model
-                     node:(BookmarkNode*)node;
+                     node:(const BookmarkNode*)node;
 - (void)nodeChildrenReordered:(BookmarkModel*)model
-                         node:(BookmarkNode*)node;
+                         node:(const BookmarkNode*)node;
 @end
 
 
diff --git a/chrome/browser/cocoa/bookmark_bar_controller.mm b/chrome/browser/cocoa/bookmark_bar_controller.mm
index ad92820..e3a4bed 100644
--- a/chrome/browser/cocoa/bookmark_bar_controller.mm
+++ b/chrome/browser/cocoa/bookmark_bar_controller.mm
@@ -143,15 +143,14 @@ const CGFloat kBookmarkHorizontalPadding = 8.0;
 // TODO(jrg): add an openBookmarkInBackground() for ctrl-click which
 // has a different disposition.
 - (void)openBookmark:(id)sender {
-  BookmarkNode* node = static_cast<BookmarkNode*>([[[sender cell]
-                                                     representedObject]
-                                                    pointerValue]);
+  const BookmarkNode* node = static_cast<const BookmarkNode*>(
+      [[[sender cell]representedObject]pointerValue]);
   DCHECK(node);
   [delegate_ openBookmarkURL:node->GetURL() disposition:CURRENT_TAB];
 }
 
 // Return an autoreleased NSCell suitable for a bookmark button.
-- (NSCell *)cellForBookmarkNode:(BookmarkNode*)node frame:(NSRect)frame {
+- (NSCell *)cellForBookmarkNode:(const BookmarkNode*)node frame:(NSRect)frame {
   NSString* title = base::SysWideToNSString(node->GetTitle());
   NSButtonCell *cell = [[[BookmarkButtonCell alloc] initTextCell:nil]
                          autorelease];
@@ -212,9 +211,9 @@ const CGFloat kBookmarkHorizontalPadding = 8.0;
 // TODO(jrg): write a "build bar" so there is a nice spot for things
 // like the contextual menu which is invoked when not over a
 // bookmark.  On Safari that menu has a "new folder" option.
-- (void)addNodesToBar:(BookmarkNode*)node {
+- (void)addNodesToBar:(const BookmarkNode*)node {
   for (int i = 0; i < node->GetChildCount(); i++) {
-    BookmarkNode* child = node->GetChild(i);
+    const BookmarkNode* child = node->GetChild(i);
 
     NSRect frame = [self frameForBookmarkAtIndex:i];
     NSButton* button = [[[NSButton alloc] initWithFrame:frame]
@@ -255,7 +254,7 @@ const CGFloat kBookmarkHorizontalPadding = 8.0;
   if ((barIsVisible_ == NO) || !model->IsLoaded())
     return;
   // Else brute force nuke and build.
-  BookmarkNode* node = model->GetBookmarkBarNode();
+  const BookmarkNode* node = model->GetBookmarkBarNode();
   [self clearBookmarkBar];
   [self addNodesToBar:node];
 }
@@ -266,32 +265,32 @@ const CGFloat kBookmarkHorizontalPadding = 8.0;
 
 // TODO(jrg): for now this is brute force.
 - (void)nodeMoved:(BookmarkModel*)model
-        oldParent:(BookmarkNode*)oldParent oldIndex:(int)oldIndex
-        newParent:(BookmarkNode*)newParent newIndex:(int)newIndex {
+        oldParent:(const BookmarkNode*)oldParent oldIndex:(int)oldIndex
+        newParent:(const BookmarkNode*)newParent newIndex:(int)newIndex {
   [self loaded:model];
 }
 
 // TODO(jrg): for now this is brute force.
 - (void)nodeAdded:(BookmarkModel*)model
-           parent:(BookmarkNode*)oldParent index:(int)index {
+           parent:(const BookmarkNode*)oldParent index:(int)index {
   [self loaded:model];
 }
 
 // TODO(jrg): for now this is brute force.
 - (void)nodeChanged:(BookmarkModel*)model
-               node:(BookmarkNode*)node {
+               node:(const BookmarkNode*)node {
   [self loaded:model];
 }
 
 // TODO(jrg): linear searching is bad.
 // Need a BookmarkNode-->NSCell mapping.
 - (void)nodeFavIconLoaded:(BookmarkModel*)model
-                     node:(BookmarkNode*)node {
+                     node:(const BookmarkNode*)node {
   NSArray* views = [bookmarkBarView_ subviews];
   for (NSButton* button in views) {
     NSButtonCell* cell = [button cell];
     void* pointer = [[cell representedObject] pointerValue];
-    BookmarkNode* cellnode = static_cast<BookmarkNode*>(pointer);
+    const BookmarkNode* cellnode = static_cast<const BookmarkNode*>(pointer);
     if (cellnode == node) {
       NSImage* image = gfx::SkBitmapToNSImage(bookmarkModel_->GetFavIcon(node));
       if (image) {
@@ -305,7 +304,7 @@ const CGFloat kBookmarkHorizontalPadding = 8.0;
 
 // TODO(jrg): for now this is brute force.
 - (void)nodeChildrenReordered:(BookmarkModel*)model
-                         node:(BookmarkNode*)node {
+                         node:(const BookmarkNode*)node {
   [self loaded:model];
 }
 
diff --git a/chrome/browser/cocoa/bookmark_menu_bridge.h b/chrome/browser/cocoa/bookmark_menu_bridge.h
index b350fd5..163514e 100644
--- a/chrome/browser/cocoa/bookmark_menu_bridge.h
+++ b/chrome/browser/cocoa/bookmark_menu_bridge.h
@@ -37,19 +37,19 @@ class BookmarkMenuBridge : public BookmarkModelObserver,
   virtual void Loaded(BookmarkModel* model);
   virtual void BookmarkModelBeingDeleted(BookmarkModel* model);
   virtual void BookmarkNodeMoved(BookmarkModel* model,
-                                 BookmarkNode* old_parent,
+                                 const BookmarkNode* old_parent,
                                  int old_index,
-                                 BookmarkNode* new_parent,
+                                 const BookmarkNode* new_parent,
                                  int new_index);
   virtual void BookmarkNodeAdded(BookmarkModel* model,
-                                 BookmarkNode* parent,
+                                 const BookmarkNode* parent,
                                  int index);
   virtual void BookmarkNodeChanged(BookmarkModel* model,
-                                   BookmarkNode* node);
+                                   const BookmarkNode* node);
   virtual void BookmarkNodeFavIconLoaded(BookmarkModel* model,
-                                         BookmarkNode* node);
+                                         const BookmarkNode* node);
   virtual void BookmarkNodeChildrenReordered(BookmarkModel* model,
-                                             BookmarkNode* node);
+                                             const BookmarkNode* node);
 
   // Overridden from BrowserList::Observer
   virtual void OnBrowserAdded(const Browser* browser);
@@ -67,7 +67,7 @@ class BookmarkMenuBridge : public BookmarkModelObserver,
   // Helper for recursively adding items to our bookmark menu
   // All children of |node| will be added to |menu|.
   // TODO(jrg): add a counter to enforce maximum nodes added
-  void AddNodeToMenu(BookmarkNode* node, NSMenu* menu);
+  void AddNodeToMenu(const BookmarkNode* node, NSMenu* menu);
 
   // Return the Bookmark menu.
   NSMenu* BookmarkMenu();
diff --git a/chrome/browser/cocoa/bookmark_menu_bridge.mm b/chrome/browser/cocoa/bookmark_menu_bridge.mm
index fc29548..d13a509 100644
--- a/chrome/browser/cocoa/bookmark_menu_bridge.mm
+++ b/chrome/browser/cocoa/bookmark_menu_bridge.mm
@@ -65,36 +65,36 @@ void BookmarkMenuBridge::BookmarkModelBeingDeleted(BookmarkModel* model) {
 }
 
 void BookmarkMenuBridge::BookmarkNodeMoved(BookmarkModel* model,
-                                           BookmarkNode* old_parent,
+                                           const BookmarkNode* old_parent,
                                            int old_index,
-                                           BookmarkNode* new_parent,
+                                           const BookmarkNode* new_parent,
                                            int new_index) {
   // TODO(jrg): this is brute force; perhaps we should be nicer.
   Loaded(model);
 }
 
 void BookmarkMenuBridge::BookmarkNodeAdded(BookmarkModel* model,
-                                           BookmarkNode* parent,
+                                           const BookmarkNode* parent,
                                            int index) {
   // TODO(jrg): this is brute force; perhaps we should be nicer.
   Loaded(model);
 }
 
 void BookmarkMenuBridge::BookmarkNodeChanged(BookmarkModel* model,
-                                             BookmarkNode* node) {
+                                             const BookmarkNode* node) {
   // TODO(jrg): this is brute force; perhaps we should be nicer.
   Loaded(model);
 }
 
 void BookmarkMenuBridge::BookmarkNodeFavIconLoaded(BookmarkModel* model,
-                                                   BookmarkNode* node) {
+                                                   const BookmarkNode* node) {
   // Nothing to do here -- no icons in the menubar menus yet.
   // TODO(jrg):
   // Both Safari and FireFox have icons in their menubars for bookmarks.
 }
 
-void BookmarkMenuBridge::BookmarkNodeChildrenReordered(BookmarkModel* model,
-                                                       BookmarkNode* node) {
+void BookmarkMenuBridge::BookmarkNodeChildrenReordered(
+    BookmarkModel* model, const BookmarkNode* node) {
   // TODO(jrg): this is brute force; perhaps we should be nicer.
   Loaded(model);
 }
@@ -171,9 +171,9 @@ const NSUInteger kMenuTrimSizeInChars = 30;
 
 }
 
-void BookmarkMenuBridge::AddNodeToMenu(BookmarkNode* node, NSMenu* menu) {
+void BookmarkMenuBridge::AddNodeToMenu(const BookmarkNode* node, NSMenu* menu) {
   for (int i = 0; i < node->GetChildCount(); i++) {
-    BookmarkNode* child = node->GetChild(i);
+    const BookmarkNode* child = node->GetChild(i);
     NSString* full_title = base::SysWideToNSString(child->GetTitle());
     NSString* title = full_title;
     if ([title length] > kMaximumMenuWidthInChars) {
diff --git a/chrome/browser/cocoa/bookmark_menu_bridge_unittest.mm b/chrome/browser/cocoa/bookmark_menu_bridge_unittest.mm
index 6cf2efb..813b03c 100644
--- a/chrome/browser/cocoa/bookmark_menu_bridge_unittest.mm
+++ b/chrome/browser/cocoa/bookmark_menu_bridge_unittest.mm
@@ -21,7 +21,7 @@ class BookmarkMenuBridgeTest : public testing::Test {
     bridge->ClearBookmarkMenu(menu);
   }
 
-  void AddNodeToMenu(BookmarkMenuBridge* bridge, BookmarkNode* root,
+  void AddNodeToMenu(BookmarkMenuBridge* bridge, const BookmarkNode* root,
                      NSMenu* menu) {
     bridge->AddNodeToMenu(root, menu);
   }
@@ -75,8 +75,8 @@ TEST_F(BookmarkMenuBridgeTest, TestAddNodeToMenu) {
   NSMenu* menu = [[[NSMenu alloc] initWithTitle:@"foo"] autorelease];
 
   BookmarkModel* model = profile->GetBookmarkModel();
-  BookmarkNode* bookmark_bar = model->GetBookmarkBarNode();
-  BookmarkNode* root = model->AddGroup(bookmark_bar, 0, empty);
+  const BookmarkNode* bookmark_bar = model->GetBookmarkBarNode();
+  const BookmarkNode* root = model->AddGroup(bookmark_bar, 0, empty);
   EXPECT_TRUE(model && root);
 
   const char* short_url = "http://foo/";
@@ -87,7 +87,7 @@ TEST_F(BookmarkMenuBridgeTest, TestAddNodeToMenu) {
 
   // 3 nodes; middle one has a child, last one has a HUGE URL
   // Set their titles to be the same as the URLs
-  BookmarkNode* node = NULL;
+  const BookmarkNode* node = NULL;
   model->AddURL(root, 0, ASCIIToWide(short_url), GURL(short_url));
   node = model->AddGroup(root, 1, empty);
   model->AddURL(root, 2, ASCIIToWide(long_url), GURL(long_url));
diff --git a/chrome/browser/cocoa/bookmark_menu_cocoa_controller.h b/chrome/browser/cocoa/bookmark_menu_cocoa_controller.h
index 83e6098..b1e9bde 100644
--- a/chrome/browser/cocoa/bookmark_menu_cocoa_controller.h
+++ b/chrome/browser/cocoa/bookmark_menu_cocoa_controller.h
@@ -29,8 +29,8 @@ class BookmarkMenuBridge;
 
 
 @interface BookmarkMenuCocoaController (ExposedForUnitTests)
-- (BookmarkNode*)nodeForIdentifier:(int)identifier;
-- (void)openURLForNode:(BookmarkNode*)node;
+- (const BookmarkNode*)nodeForIdentifier:(int)identifier;
+- (void)openURLForNode:(const BookmarkNode*)node;
 @end  // BookmarkMenuCocoaController (ExposedForUnitTests)
 
 #endif  // CHROME_BROWSER_COCOA_BOOKMARK_MENU_COCOA_CONTROLLER_H_
diff --git a/chrome/browser/cocoa/bookmark_menu_cocoa_controller.mm b/chrome/browser/cocoa/bookmark_menu_cocoa_controller.mm
index 3aa9906..25b2b4c 100644
--- a/chrome/browser/cocoa/bookmark_menu_cocoa_controller.mm
+++ b/chrome/browser/cocoa/bookmark_menu_cocoa_controller.mm
@@ -21,12 +21,12 @@
 
 // Return the a BookmarkNode that has the given id (called
 // "identifier" here to avoid conflict with objc's concept of "id").
-- (BookmarkNode*)nodeForIdentifier:(int)identifier {
+- (const BookmarkNode*)nodeForIdentifier:(int)identifier {
   return bridge_->GetBookmarkModel()->GetNodeByID(identifier);
 }
 
 // Open the URL of the given BookmarkNode in the current tab.
-- (void)openURLForNode:(BookmarkNode*)node {
+- (void)openURLForNode:(const BookmarkNode*)node {
   Browser* browser = BrowserList::GetLastActive();
 
   if (!browser) {  // No windows open?
@@ -45,7 +45,7 @@
 - (IBAction)openBookmarkMenuItem:(id)sender {
   NSInteger tag = [sender tag];
   int identifier = tag;
-  BookmarkNode* node = [self nodeForIdentifier:identifier];
+  const BookmarkNode* node = [self nodeForIdentifier:identifier];
   DCHECK(node);
   if (!node)
     return;  // shouldn't be reached
diff --git a/chrome/browser/cocoa/bookmark_menu_cocoa_controller_unittest.mm b/chrome/browser/cocoa/bookmark_menu_cocoa_controller_unittest.mm
index 90895fc..23ecf3e 100644
--- a/chrome/browser/cocoa/bookmark_menu_cocoa_controller_unittest.mm
+++ b/chrome/browser/cocoa/bookmark_menu_cocoa_controller_unittest.mm
@@ -11,7 +11,7 @@
 @interface FakeBookmarkMenuController : BookmarkMenuCocoaController {
  @public
   BrowserTestHelper* helper_;
-  BookmarkNode* nodes_[2];
+  const BookmarkNode* nodes_[2];
   BOOL opened_[2];
 }
 @end
@@ -23,7 +23,7 @@
     std::wstring empty;
     helper_ = new BrowserTestHelper();
     BookmarkModel* model = helper_->browser()->profile()->GetBookmarkModel();
-    BookmarkNode* bookmark_bar = model->GetBookmarkBarNode();
+    const BookmarkNode* bookmark_bar = model->GetBookmarkBarNode();
     nodes_[0] = model->AddURL(bookmark_bar, 0, empty, GURL("http://0.com"));
     nodes_[1] = model->AddURL(bookmark_bar, 1, empty, GURL("http://1.com"));
   }
@@ -35,13 +35,13 @@
   [super dealloc];
 }
 
-- (BookmarkNode*)nodeForIdentifier:(int)identifier {
+- (const BookmarkNode*)nodeForIdentifier:(int)identifier {
   if ((identifier < 0) || (identifier >= 2))
     return NULL;
   return nodes_[identifier];
 }
 
-- (void)openURLForNode:(BookmarkNode*)node {
+- (void)openURLForNode:(const BookmarkNode*)node {
   std::string url = node->GetURL().possibly_invalid_spec();
   if (url.find("http://0.com") != std::string::npos)
     opened_[0] = YES;
diff --git a/chrome/browser/dom_ui/new_tab_ui.cc b/chrome/browser/dom_ui/new_tab_ui.cc
index 2c4de50..9be3e72 100644
--- a/chrome/browser/dom_ui/new_tab_ui.cc
+++ b/chrome/browser/dom_ui/new_tab_ui.cc
@@ -1005,24 +1005,24 @@ class RecentlyBookmarkedHandler : public DOMMessageHandler,
   // BookmarkModelObserver methods. These invoke SendBookmarksToPage.
   virtual void Loaded(BookmarkModel* model);
   virtual void BookmarkNodeAdded(BookmarkModel* model,
-                                 BookmarkNode* parent,
+                                 const BookmarkNode* parent,
                                  int index);
   virtual void BookmarkNodeRemoved(BookmarkModel* model,
-                                   BookmarkNode* parent,
+                                   const BookmarkNode* parent,
                                    int index);
   virtual void BookmarkNodeChanged(BookmarkModel* model,
-                                   BookmarkNode* node);
+                                   const BookmarkNode* node);
 
   // These won't effect what is shown, so they do nothing.
   virtual void BookmarkNodeMoved(BookmarkModel* model,
-                                 BookmarkNode* old_parent,
+                                 const BookmarkNode* old_parent,
                                  int old_index,
-                                 BookmarkNode* new_parent,
+                                 const BookmarkNode* new_parent,
                                  int new_index) {}
   virtual void BookmarkNodeChildrenReordered(BookmarkModel* model,
-                                             BookmarkNode* node) {}
+                                             const BookmarkNode* node) {}
   virtual void BookmarkNodeFavIconLoaded(BookmarkModel* model,
-                                         BookmarkNode* node) {}
+                                         const BookmarkNode* node) {}
 
   DOMUI* dom_ui_;
   // The model we're getting bookmarks from. The model is owned by the Profile.
@@ -1057,12 +1057,12 @@ void RecentlyBookmarkedHandler::HandleGetRecentlyBookmarked(const Value*) {
 }
 
 void RecentlyBookmarkedHandler::SendBookmarksToPage() {
-  std::vector<BookmarkNode*> recently_bookmarked;
+  std::vector<const BookmarkNode*> recently_bookmarked;
   bookmark_utils::GetMostRecentlyAddedEntries(
       model_, kRecentBookmarks, &recently_bookmarked);
   ListValue list_value;
   for (size_t i = 0; i < recently_bookmarked.size(); ++i) {
-    BookmarkNode* node = recently_bookmarked[i];
+    const BookmarkNode* node = recently_bookmarked[i];
     DictionaryValue* entry_value = new DictionaryValue;
     SetURLTitleAndDirection(entry_value,
                             WideToUTF16(node->GetTitle()), node->GetURL());
@@ -1078,19 +1078,19 @@ void RecentlyBookmarkedHandler::Loaded(BookmarkModel* model) {
 }
 
 void RecentlyBookmarkedHandler::BookmarkNodeAdded(BookmarkModel* model,
-                                                  BookmarkNode* parent,
+                                                  const BookmarkNode* parent,
                                                   int index) {
   SendBookmarksToPage();
 }
 
 void RecentlyBookmarkedHandler::BookmarkNodeRemoved(BookmarkModel* model,
-                                                    BookmarkNode* parent,
+                                                    const BookmarkNode* parent,
                                                     int index) {
   SendBookmarksToPage();
 }
 
 void RecentlyBookmarkedHandler::BookmarkNodeChanged(BookmarkModel* model,
-                                                    BookmarkNode* node) {
+                                                    const BookmarkNode* node) {
   SendBookmarksToPage();
 }
 
diff --git a/chrome/browser/extensions/extension_bookmarks_module.cc b/chrome/browser/extensions/extension_bookmarks_module.cc
index c12062a..f25bd40 100644
--- a/chrome/browser/extensions/extension_bookmarks_module.cc
+++ b/chrome/browser/extensions/extension_bookmarks_module.cc
@@ -22,11 +22,12 @@ namespace keys = extension_bookmarks_module_constants;
 class ExtensionBookmarks {
  public:
   // Convert |node| into a JSON value
-  static DictionaryValue* GetNodeDictionary(BookmarkNode* node, bool recurse) {
+  static DictionaryValue* GetNodeDictionary(const BookmarkNode* node,
+                                            bool recurse) {
     DictionaryValue* dict = new DictionaryValue();
     dict->SetInteger(keys::kIdKey, node->id());
 
-    BookmarkNode* parent = node->GetParent();
+    const BookmarkNode* parent = node->GetParent();
     if (parent)
       dict->SetInteger(keys::kParentIdKey, parent->id());
 
@@ -38,7 +39,7 @@ class ExtensionBookmarks {
     int childCount = node->GetChildCount();
     ListValue* children = new ListValue();
     for (int i = 0; i < childCount; ++i) {
-      BookmarkNode* child = node->GetChild(i);
+      const BookmarkNode* child = node->GetChild(i);
       if (recurse) {
         DictionaryValue* dict = GetNodeDictionary(child, true);
         children->Append(dict);
@@ -50,14 +51,14 @@ class ExtensionBookmarks {
   }
 
   // Add a JSON representation of |node| to the JSON |list|.
-  static void AddNode(BookmarkNode* node, ListValue* list, bool recurse) {
+  static void AddNode(const BookmarkNode* node, ListValue* list, bool recurse) {
     DictionaryValue* dict = GetNodeDictionary(node, recurse);
     list->Append(dict);
   }
 
   static bool RemoveNode(BookmarkModel* model, int id, bool recursive,
                          std::string* error) {
-    BookmarkNode* node = model->GetNodeByID(id);
+    const BookmarkNode* node = model->GetNodeByID(id);
     if (!node) {
       *error = keys::kNoNodeError;
       return false;
@@ -73,7 +74,7 @@ class ExtensionBookmarks {
       return false;
     }
 
-    BookmarkNode* parent = node->GetParent();
+    const BookmarkNode* parent = node->GetParent();
     int index = parent->IndexOfChild(node);
     model->Remove(parent, index);
     return true;
@@ -140,13 +141,14 @@ void ExtensionBookmarkEventRouter::Loaded(BookmarkModel* model) {
   // so they know when it's safe to use the API?
 }
 
-void ExtensionBookmarkEventRouter::BookmarkNodeMoved(BookmarkModel* model,
-                                                     BookmarkNode* old_parent,
-                                                     int old_index,
-                                                     BookmarkNode* new_parent,
-                                                     int new_index) {
+void ExtensionBookmarkEventRouter::BookmarkNodeMoved(
+    BookmarkModel* model,
+    const BookmarkNode* old_parent,
+    int old_index,
+    const BookmarkNode* new_parent,
+    int new_index) {
   ListValue args;
-  BookmarkNode* node = new_parent->GetChild(new_index);
+  const BookmarkNode* node = new_parent->GetChild(new_index);
   args.Append(new FundamentalValue(node->id()));
   DictionaryValue* object_args = new DictionaryValue();
   object_args->SetInteger(keys::kParentIdKey, new_parent->id());
@@ -161,10 +163,10 @@ void ExtensionBookmarkEventRouter::BookmarkNodeMoved(BookmarkModel* model,
 }
 
 void ExtensionBookmarkEventRouter::BookmarkNodeAdded(BookmarkModel* model,
-                                                     BookmarkNode* parent,
+                                                     const BookmarkNode* parent,
                                                      int index) {
   ListValue args;
-  BookmarkNode* node = parent->GetChild(index);
+  const BookmarkNode* node = parent->GetChild(index);
   args.Append(new FundamentalValue(node->id()));
   DictionaryValue* object_args = new DictionaryValue();
   object_args->SetString(keys::kTitleKey, node->GetTitle());
@@ -178,9 +180,10 @@ void ExtensionBookmarkEventRouter::BookmarkNodeAdded(BookmarkModel* model,
   DispatchEvent(model->profile(), keys::kOnBookmarkAdded, json_args);
 }
 
-void ExtensionBookmarkEventRouter::BookmarkNodeRemoved(BookmarkModel* model,
-                                                       BookmarkNode* parent,
-                                                       int index) {
+void ExtensionBookmarkEventRouter::BookmarkNodeRemoved(
+    BookmarkModel* model,
+    const BookmarkNode* parent,
+    int index) {
   ListValue args;
   DictionaryValue* object_args = new DictionaryValue();
   object_args->SetInteger(keys::kParentIdKey, parent->id());
@@ -192,8 +195,8 @@ void ExtensionBookmarkEventRouter::BookmarkNodeRemoved(BookmarkModel* model,
   DispatchEvent(model->profile(), keys::kOnBookmarkRemoved, json_args);
 }
 
-void ExtensionBookmarkEventRouter::BookmarkNodeChanged(BookmarkModel* model,
-                                                       BookmarkNode* node) {
+void ExtensionBookmarkEventRouter::BookmarkNodeChanged(
+    BookmarkModel* model, const BookmarkNode* node) {
   ListValue args;
   args.Append(new FundamentalValue(node->id()));
 
@@ -212,18 +215,18 @@ void ExtensionBookmarkEventRouter::BookmarkNodeChanged(BookmarkModel* model,
 }
 
 void ExtensionBookmarkEventRouter::BookmarkNodeFavIconLoaded(
-    BookmarkModel* model, BookmarkNode* node) {
+    BookmarkModel* model, const BookmarkNode* node) {
   // TODO(erikkay) anything we should do here?
 }
 
 void ExtensionBookmarkEventRouter::BookmarkNodeChildrenReordered(
-    BookmarkModel* model, BookmarkNode* node) {
+    BookmarkModel* model, const BookmarkNode* node) {
   ListValue args;
   args.Append(new FundamentalValue(node->id()));
   int childCount = node->GetChildCount();
   ListValue* children = new ListValue();
   for (int i = 0; i < childCount; ++i) {
-    BookmarkNode* child = node->GetChild(i);
+    const BookmarkNode* child = node->GetChild(i);
     Value* child_id = new FundamentalValue(child->id());
     children->Append(child_id);
   }
@@ -246,7 +249,7 @@ bool GetBookmarksFunction::RunImpl() {
     for (size_t i = 0; i < count; ++i) {
       int id = 0;
       EXTENSION_FUNCTION_VALIDATE(ids->GetInteger(i, &id));
-      BookmarkNode* node = model->GetNodeByID(id);
+      const BookmarkNode* node = model->GetNodeByID(id);
       if (!node) {
         error_ = keys::kNoNodeError;
         return false;
@@ -257,7 +260,7 @@ bool GetBookmarksFunction::RunImpl() {
   } else {
     int id;
     EXTENSION_FUNCTION_VALIDATE(args_->GetAsInteger(&id));
-    BookmarkNode* node = model->GetNodeByID(id);
+    const BookmarkNode* node = model->GetNodeByID(id);
     if (!node) {
       error_ = keys::kNoNodeError;
       return false;
@@ -274,14 +277,14 @@ bool GetBookmarkChildrenFunction::RunImpl() {
   int id;
   EXTENSION_FUNCTION_VALIDATE(args_->GetAsInteger(&id));
   scoped_ptr<ListValue> json(new ListValue());
-  BookmarkNode* node = model->GetNodeByID(id);
+  const BookmarkNode* node = model->GetNodeByID(id);
   if (!node) {
     error_ = keys::kNoNodeError;
     return false;
   }
   int child_count = node->GetChildCount();
   for (int i = 0; i < child_count; ++i) {
-    BookmarkNode* child = node->GetChild(i);
+    const BookmarkNode* child = node->GetChild(i);
     ExtensionBookmarks::AddNode(child, json.get(), false);
   }
 
@@ -292,7 +295,7 @@ bool GetBookmarkChildrenFunction::RunImpl() {
 bool GetBookmarkTreeFunction::RunImpl() {
   BookmarkModel* model = profile()->GetBookmarkModel();
   scoped_ptr<ListValue> json(new ListValue());
-  BookmarkNode* node = model->root_node();
+  const BookmarkNode* node = model->root_node();
   ExtensionBookmarks::AddNode(node, json.get(), true);
   result_.reset(json.release());
   return true;
@@ -307,11 +310,11 @@ bool SearchBookmarksFunction::RunImpl() {
   BookmarkModel* model = profile()->GetBookmarkModel();
   ListValue* json = new ListValue();
   std::wstring lang = profile()->GetPrefs()->GetString(prefs::kAcceptLanguages);
-  std::vector<BookmarkNode*> nodes;
+  std::vector<const BookmarkNode*> nodes;
   bookmark_utils::GetBookmarksContainingText(model, query, 50, lang, &nodes);
-  std::vector<BookmarkNode*>::iterator i = nodes.begin();
+  std::vector<const BookmarkNode*>::iterator i = nodes.begin();
   for (; i != nodes.end(); ++i) {
-    BookmarkNode* node = *i;
+    const BookmarkNode* node = *i;
     ExtensionBookmarks::AddNode(node, json, false);
   }
 
@@ -356,7 +359,7 @@ bool CreateBookmarkFunction::RunImpl() {
     EXTENSION_FUNCTION_VALIDATE(json->GetInteger(keys::kParentIdKey,
                                                  &parentId));
   }
-  BookmarkNode* parent = model->GetNodeByID(parentId);
+  const BookmarkNode* parent = model->GetNodeByID(parentId);
   if (!parent) {
     error_ = keys::kNoParentError;
     return false;
@@ -387,7 +390,7 @@ bool CreateBookmarkFunction::RunImpl() {
     return false;
   }
 
-  BookmarkNode* node;
+  const BookmarkNode* node;
   if (url_string.length())
     node = model->AddURL(parent, index, title, url);
   else
@@ -413,7 +416,7 @@ bool MoveBookmarkFunction::RunImpl() {
   EXTENSION_FUNCTION_VALIDATE(args->GetDictionary(1, &destination));
 
   BookmarkModel* model = profile()->GetBookmarkModel();
-  BookmarkNode* node = model->GetNodeByID(id);
+  const BookmarkNode* node = model->GetNodeByID(id);
   if (!node) {
     error_ = keys::kNoNodeError;
     return false;
@@ -425,7 +428,7 @@ bool MoveBookmarkFunction::RunImpl() {
     return false;
   }
 
-  BookmarkNode* parent;
+  const BookmarkNode* parent;
   if (!destination->HasKey(keys::kParentIdKey)) {
     // optional, defaults to current parent
     parent = node->GetParent();
@@ -471,7 +474,7 @@ bool SetBookmarkTitleFunction::RunImpl() {
   BookmarkModel* model = profile()->GetBookmarkModel();
   int id = 0;
   EXTENSION_FUNCTION_VALIDATE(json->GetInteger(keys::kIdKey, &id));
-  BookmarkNode* node = model->GetNodeByID(id);
+  const BookmarkNode* node = model->GetNodeByID(id);
   if (!node) {
     error_ = keys::kNoNodeError;
     return false;
diff --git a/chrome/browser/extensions/extension_bookmarks_module.h b/chrome/browser/extensions/extension_bookmarks_module.h
index 8dc795e..426e145 100644
--- a/chrome/browser/extensions/extension_bookmarks_module.h
+++ b/chrome/browser/extensions/extension_bookmarks_module.h
@@ -27,28 +27,28 @@ class ExtensionBookmarkEventRouter : public BookmarkModelObserver {
   virtual void Loaded(BookmarkModel* model);
   virtual void BookmarkModelBeingDeleted(BookmarkModel* model) { }
   virtual void BookmarkNodeMoved(BookmarkModel* model,
-                                 BookmarkNode* old_parent,
+                                 const BookmarkNode* old_parent,
                                  int old_index,
-                                 BookmarkNode* new_parent,
+                                 const BookmarkNode* new_parent,
                                  int new_index);
   virtual void BookmarkNodeAdded(BookmarkModel* model,
-                                 BookmarkNode* parent,
+                                 const BookmarkNode* parent,
                                  int index);
   virtual void BookmarkNodeRemoved(BookmarkModel* model,
-                                   BookmarkNode* parent,
+                                   const BookmarkNode* parent,
                                    int index);
   virtual void BookmarkNodeRemoved(BookmarkModel* model,
-                                   BookmarkNode* parent,
+                                   const BookmarkNode* parent,
                                    int old_index,
-                                   BookmarkNode* node) {
+                                   const BookmarkNode* node) {
     BookmarkNodeRemoved(model, parent, old_index);
   }
   virtual void BookmarkNodeChanged(BookmarkModel* model,
-                                   BookmarkNode* node);
+                                   const BookmarkNode* node);
   virtual void BookmarkNodeFavIconLoaded(BookmarkModel* model,
-                                         BookmarkNode* node);
+                                         const BookmarkNode* node);
   virtual void BookmarkNodeChildrenReordered(BookmarkModel* model,
-                                             BookmarkNode* node);
+                                             const BookmarkNode* node);
 
  private:
   ExtensionBookmarkEventRouter();
diff --git a/chrome/browser/gtk/bookmark_bar_gtk.cc b/chrome/browser/gtk/bookmark_bar_gtk.cc
index cfadd13..dc86bab 100644
--- a/chrome/browser/gtk/bookmark_bar_gtk.cc
+++ b/chrome/browser/gtk/bookmark_bar_gtk.cc
@@ -279,7 +279,7 @@ void BookmarkBarGtk::Loaded(BookmarkModel* model) {
     return;
   RemoveAllBookmarkButtons();
 
-  BookmarkNode* node = model_->GetBookmarkBarNode();
+  const BookmarkNode* node = model_->GetBookmarkBarNode();
   DCHECK(node && model_->other_node());
   CreateAllBookmarkButtons(node);
 
@@ -297,16 +297,16 @@ void BookmarkBarGtk::BookmarkModelBeingDeleted(BookmarkModel* model) {
 }
 
 void BookmarkBarGtk::BookmarkNodeMoved(BookmarkModel* model,
-                                       BookmarkNode* old_parent,
+                                       const BookmarkNode* old_parent,
                                        int old_index,
-                                       BookmarkNode* new_parent,
+                                       const BookmarkNode* new_parent,
                                        int new_index) {
   BookmarkNodeRemoved(model, old_parent, old_index);
   BookmarkNodeAdded(model, new_parent, new_index);
 }
 
 void BookmarkBarGtk::BookmarkNodeAdded(BookmarkModel* model,
-                                       BookmarkNode* parent,
+                                       const BookmarkNode* parent,
                                        int index) {
   if (parent != model_->GetBookmarkBarNode()) {
     // We only care about nodes on the bookmark bar.
@@ -322,7 +322,7 @@ void BookmarkBarGtk::BookmarkNodeAdded(BookmarkModel* model,
 }
 
 void BookmarkBarGtk::BookmarkNodeRemoved(BookmarkModel* model,
-                                         BookmarkNode* parent,
+                                         const BookmarkNode* parent,
                                          int index) {
   if (parent != model_->GetBookmarkBarNode()) {
     // We only care about nodes on the bookmark bar.
@@ -339,7 +339,7 @@ void BookmarkBarGtk::BookmarkNodeRemoved(BookmarkModel* model,
 }
 
 void BookmarkBarGtk::BookmarkNodeChanged(BookmarkModel* model,
-                                         BookmarkNode* node) {
+                                         const BookmarkNode* node) {
   if (node->GetParent() != model_->GetBookmarkBarNode()) {
     // We only care about nodes on the bookmark bar.
     return;
@@ -354,12 +354,12 @@ void BookmarkBarGtk::BookmarkNodeChanged(BookmarkModel* model,
 }
 
 void BookmarkBarGtk::BookmarkNodeFavIconLoaded(BookmarkModel* model,
-                                               BookmarkNode* node) {
+                                               const BookmarkNode* node) {
   BookmarkNodeChanged(model, node);
 }
 
 void BookmarkBarGtk::BookmarkNodeChildrenReordered(BookmarkModel* model,
-                                                   BookmarkNode* node) {
+                                                   const BookmarkNode* node) {
   if (node != model_->GetBookmarkBarNode())
     return;  // We only care about reordering of the bookmark bar node.
 
@@ -368,7 +368,7 @@ void BookmarkBarGtk::BookmarkNodeChildrenReordered(BookmarkModel* model,
   CreateAllBookmarkButtons(node);
 }
 
-void BookmarkBarGtk::CreateAllBookmarkButtons(BookmarkNode* node) {
+void BookmarkBarGtk::CreateAllBookmarkButtons(const BookmarkNode* node) {
   // Create a button for each of the children on the bookmark bar.
   for (int i = 0; i < node->GetChildCount(); ++i) {
     GtkToolItem* item = CreateBookmarkToolItem(node->GetChild(i));
@@ -378,7 +378,8 @@ void BookmarkBarGtk::CreateAllBookmarkButtons(BookmarkNode* node) {
   SetInstructionState(node);
 }
 
-void BookmarkBarGtk::SetInstructionState(BookmarkNode* boomarks_bar_node) {
+void BookmarkBarGtk::SetInstructionState(
+    const BookmarkNode* boomarks_bar_node) {
   show_instructions_ = (boomarks_bar_node->GetChildCount() == 0);
   if (show_instructions_) {
     gtk_widget_show_all(instructions_);
@@ -418,7 +419,7 @@ void BookmarkBarGtk::AnimationEnded(const Animation* animation) {
     gtk_widget_hide(bookmark_hbox_.get());
 }
 
-void BookmarkBarGtk::ConfigureButtonForNode(BookmarkNode* node,
+void BookmarkBarGtk::ConfigureButtonForNode(const BookmarkNode* node,
                                             GtkWidget* button) {
   std::string tooltip = BuildTooltip(node);
   if (!tooltip.empty())
@@ -439,10 +440,10 @@ void BookmarkBarGtk::ConfigureButtonForNode(BookmarkNode* node,
 
   SetButtonTextColors(button);
   g_object_set_data(G_OBJECT(button), kBookmarkNode,
-                    reinterpret_cast<void*>(node));
+                    reinterpret_cast<void*>(const_cast<BookmarkNode*>(node)));
 }
 
-GtkWidget* BookmarkBarGtk::CreateBookmarkButton(BookmarkNode* node) {
+GtkWidget* BookmarkBarGtk::CreateBookmarkButton(const BookmarkNode* node) {
   GtkWidget* button = gtk_chrome_button_new();
   ConfigureButtonForNode(node, button);
 
@@ -477,7 +478,7 @@ GtkWidget* BookmarkBarGtk::CreateBookmarkButton(BookmarkNode* node) {
   return button;
 }
 
-GtkToolItem* BookmarkBarGtk::CreateBookmarkToolItem(BookmarkNode* node) {
+GtkToolItem* BookmarkBarGtk::CreateBookmarkToolItem(const BookmarkNode* node) {
   GtkWidget* button = CreateBookmarkButton(node);
   g_object_set_data(G_OBJECT(button), "left-align-popup",
                     reinterpret_cast<void*>(true));
@@ -499,13 +500,13 @@ void BookmarkBarGtk::ConnectFolderButtonEvents(GtkWidget* widget) {
                    G_CALLBACK(OnFolderButtonReleased), this);
 }
 
-std::string BookmarkBarGtk::BuildTooltip(BookmarkNode* node) {
+std::string BookmarkBarGtk::BuildTooltip(const BookmarkNode* node) {
   // TODO(erg): Actually build the tooltip. For now, we punt and just return
   // the URL.
   return node->GetURL().possibly_invalid_spec();
 }
 
-BookmarkNode* BookmarkBarGtk::GetNodeForToolButton(GtkWidget* widget) {
+const BookmarkNode* BookmarkBarGtk::GetNodeForToolButton(GtkWidget* widget) {
   // First check to see if |button| is special cased.
   if (widget == other_bookmarks_button_)
     return model_->other_node();
@@ -542,15 +543,16 @@ void BookmarkBarGtk::InitBackground() {
       0, IDR_THEME_TOOLBAR, 0, 0, 0, 0, 0, 0, 0));
 }
 
-void BookmarkBarGtk::PopupMenuForNode(GtkWidget* sender, BookmarkNode* node,
+void BookmarkBarGtk::PopupMenuForNode(GtkWidget* sender,
+                                      const BookmarkNode* node,
                                       GdkEventButton* event) {
   if (!model_->IsLoaded()) {
     // Don't do anything if the model isn't loaded.
     return;
   }
 
-  BookmarkNode* parent = NULL;
-  std::vector<BookmarkNode*> nodes;
+  const BookmarkNode* parent = NULL;
+  std::vector<const BookmarkNode*> nodes;
   if (sender == other_bookmarks_button_) {
     parent = model_->GetBookmarkBarNode();
     nodes.push_back(parent);
@@ -578,7 +580,7 @@ gboolean BookmarkBarGtk::OnButtonPressed(GtkWidget* sender,
     bar->ignore_button_release_ = false;
 
   if (event->button == 3) {
-    BookmarkNode* node = bar->GetNodeForToolButton(sender);
+    const BookmarkNode* node = bar->GetNodeForToolButton(sender);
     DCHECK(node);
     DCHECK(bar->page_navigator_);
     bar->PopupMenuForNode(sender, node, event);
@@ -597,7 +599,7 @@ gboolean BookmarkBarGtk::OnButtonReleased(GtkWidget* sender,
     return FALSE;
   }
 
-  BookmarkNode* node = bar->GetNodeForToolButton(sender);
+  const BookmarkNode* node = bar->GetNodeForToolButton(sender);
   DCHECK(node);
   DCHECK(bar->page_navigator_);
 
@@ -630,7 +632,7 @@ void BookmarkBarGtk::OnButtonDragBegin(GtkWidget* button,
   // pressing.
   bar->ignore_button_release_ = true;
 
-  BookmarkNode* node = bar->GetNodeForToolButton(button);
+  const BookmarkNode* node = bar->GetNodeForToolButton(button);
   DCHECK(!bar->dragged_node_);
   bar->dragged_node_ = node;
   DCHECK(bar->dragged_node_);
@@ -680,8 +682,8 @@ void BookmarkBarGtk::OnButtonDragGet(GtkWidget* widget, GdkDragContext* context,
                                      GtkSelectionData* selection_data,
                                      guint target_type, guint time,
                                      BookmarkBarGtk* bar) {
-  BookmarkNode* node =
-      reinterpret_cast<BookmarkNode*>(
+  const BookmarkNode* node =
+      reinterpret_cast<const BookmarkNode*>(
           g_object_get_data(G_OBJECT(widget), kBookmarkNode));
   bookmark_utils::WriteBookmarkToSelection(node, selection_data, target_type,
                                            bar->profile_);
@@ -697,7 +699,7 @@ gboolean BookmarkBarGtk::OnFolderButtonReleased(GtkWidget* sender,
     return FALSE;
   }
 
-  BookmarkNode* node = bar->GetNodeForToolButton(sender);
+  const BookmarkNode* node = bar->GetNodeForToolButton(sender);
   DCHECK(node);
   DCHECK(bar->page_navigator_);
 
@@ -807,7 +809,7 @@ void BookmarkBarGtk::OnToolbarDragReceived(GtkWidget* widget,
   gboolean dnd_success = FALSE;
   gboolean delete_selection_data = FALSE;
 
-  std::vector<BookmarkNode*> nodes =
+  std::vector<const BookmarkNode*> nodes =
       bookmark_utils::GetNodesFromSelection(context, selection_data,
                                             target_type,
                                             bar->profile_,
@@ -816,7 +818,7 @@ void BookmarkBarGtk::OnToolbarDragReceived(GtkWidget* widget,
   DCHECK(!nodes.empty());
   gint index = gtk_toolbar_get_drop_index(
       GTK_TOOLBAR(bar->bookmark_toolbar_.get()), x, y);
-  for (std::vector<BookmarkNode*>::iterator it = nodes.begin();
+  for (std::vector<const BookmarkNode*>::iterator it = nodes.begin();
        it != nodes.end(); ++it) {
     bar->model_->Move(*it, bar->model_->GetBookmarkBarNode(), index);
     index = bar->model_->GetBookmarkBarNode()->IndexOfChild(*it) + 1;
diff --git a/chrome/browser/gtk/bookmark_bar_gtk.h b/chrome/browser/gtk/bookmark_bar_gtk.h
index 154dc36..be07088 100644
--- a/chrome/browser/gtk/bookmark_bar_gtk.h
+++ b/chrome/browser/gtk/bookmark_bar_gtk.h
@@ -74,15 +74,15 @@ class BookmarkBarGtk : public AnimationDelegate,
  private:
   // Helper function that sets visual properties of GtkButton |button| to the
   // contents of |node|.
-  void ConfigureButtonForNode(BookmarkNode* node,
+  void ConfigureButtonForNode(const BookmarkNode* node,
                               GtkWidget* button);
 
   // Helper function which generates GtkToolItems for |bookmark_toolbar_|.
-  void CreateAllBookmarkButtons(BookmarkNode* node);
+  void CreateAllBookmarkButtons(const BookmarkNode* node);
 
   // Sets the visibility of the instructional text based on whether there are
   // any bookmarks in |node|. |node| is assumed to be the bookmarks bar node.
-  void SetInstructionState(BookmarkNode* boomarks_bar_node);
+  void SetInstructionState(const BookmarkNode* boomarks_bar_node);
 
   // Helper function which destroys all the bookmark buttons in the GtkToolbar.
   void RemoveAllBookmarkButtons();
@@ -103,40 +103,40 @@ class BookmarkBarGtk : public AnimationDelegate,
 
   // Invoked when a node has moved.
   virtual void BookmarkNodeMoved(BookmarkModel* model,
-                                 BookmarkNode* old_parent,
+                                 const BookmarkNode* old_parent,
                                  int old_index,
-                                 BookmarkNode* new_parent,
+                                 const BookmarkNode* new_parent,
                                  int new_index);
   virtual void BookmarkNodeAdded(BookmarkModel* model,
-                                 BookmarkNode* parent,
+                                 const BookmarkNode* parent,
                                  int index);
   virtual void BookmarkNodeRemoved(BookmarkModel* model,
-                                   BookmarkNode* parent,
+                                   const BookmarkNode* parent,
                                    int index);
   virtual void BookmarkNodeChanged(BookmarkModel* model,
-                                   BookmarkNode* node);
+                                   const BookmarkNode* node);
   // Invoked when a favicon has finished loading.
   virtual void BookmarkNodeFavIconLoaded(BookmarkModel* model,
-                                         BookmarkNode* node);
+                                         const BookmarkNode* node);
   virtual void BookmarkNodeChildrenReordered(BookmarkModel* model,
-                                             BookmarkNode* node);
+                                             const BookmarkNode* node);
 
  private:
-  GtkWidget* CreateBookmarkButton(BookmarkNode* node);
-  GtkToolItem* CreateBookmarkToolItem(BookmarkNode* node);
+  GtkWidget* CreateBookmarkButton(const BookmarkNode* node);
+  GtkToolItem* CreateBookmarkToolItem(const BookmarkNode* node);
 
   void ConnectFolderButtonEvents(GtkWidget* widget);
 
-  std::string BuildTooltip(BookmarkNode* node);
+  std::string BuildTooltip(const BookmarkNode* node);
 
   // Finds the BookmarkNode from the model associated with |button|.
-  BookmarkNode* GetNodeForToolButton(GtkWidget* button);
+  const BookmarkNode* GetNodeForToolButton(GtkWidget* button);
 
   // Loads the background image into memory, or does nothing if already loaded.
   void InitBackground();
 
   // Creates and displays a popup menu for BookmarkNode |node|.
-  void PopupMenuForNode(GtkWidget* sender, BookmarkNode* node,
+  void PopupMenuForNode(GtkWidget* sender, const BookmarkNode* node,
                         GdkEventButton* event);
 
   // GtkButton callbacks
@@ -221,7 +221,7 @@ class BookmarkBarGtk : public AnimationDelegate,
 
   // The BookmarkNode from the model being dragged. NULL when we aren't
   // dragging.
-  BookmarkNode* dragged_node_;
+  const BookmarkNode* dragged_node_;
 
   // We create a GtkToolbarItem from |dragged_node_| for display.
   GtkToolItem* toolbar_drop_item_;
diff --git a/chrome/browser/gtk/bookmark_bubble_gtk.cc b/chrome/browser/gtk/bookmark_bubble_gtk.cc
index ae07e3d..30e93d6 100644
--- a/chrome/browser/gtk/bookmark_bubble_gtk.cc
+++ b/chrome/browser/gtk/bookmark_bubble_gtk.cc
@@ -31,19 +31,19 @@ BookmarkBubbleGtk* g_bubble = NULL;
 // Max number of most recently used folders.
 const size_t kMaxMRUFolders = 5;
 
-std::vector<BookmarkNode*> PopulateFolderCombo(BookmarkModel* model,
-                                               const GURL& url,
-                                               GtkWidget* folder_combo) {
-  BookmarkNode* node = model->GetMostRecentlyAddedNodeForURL(url);
-  BookmarkNode* parent = node->GetParent();
-  BookmarkNode* bookmark_bar = model->GetBookmarkBarNode();
-  BookmarkNode* other = model->other_node();
+std::vector<const BookmarkNode*> PopulateFolderCombo(BookmarkModel* model,
+                                                     const GURL& url,
+                                                     GtkWidget* folder_combo) {
+  const BookmarkNode* node = model->GetMostRecentlyAddedNodeForURL(url);
+  const BookmarkNode* parent = node->GetParent();
+  const BookmarkNode* bookmark_bar = model->GetBookmarkBarNode();
+  const BookmarkNode* other = model->other_node();
 
   // Use + 2 to account for bookmark bar and other node.
-  std::vector<BookmarkNode*> recent_nodes =
+  std::vector<const BookmarkNode*> recent_nodes =
       bookmark_utils::GetMostRecentlyModifiedGroups(model, kMaxMRUFolders + 2);
 
-  std::vector<BookmarkNode*> nodes;
+  std::vector<const BookmarkNode*> nodes;
   // Make the parent the first item, unless it's the bookmark bar or other node.
   if (parent != bookmark_bar && parent != other)
     nodes.push_back(parent);
@@ -217,7 +217,7 @@ BookmarkBubbleGtk::~BookmarkBubbleGtk() {
     ApplyEdits();
   } else if (remove_bookmark_) {
     BookmarkModel* model = profile_->GetBookmarkModel();
-    BookmarkNode* node = model->GetMostRecentlyAddedNodeForURL(url_);
+    const BookmarkNode* node = model->GetMostRecentlyAddedNodeForURL(url_);
     if (node)
       model->Remove(node->GetParent(), node->GetParent()->IndexOfChild(node));
   }
@@ -269,7 +269,7 @@ void BookmarkBubbleGtk::ApplyEdits() {
   apply_edits_ = false;
 
   BookmarkModel* model = profile_->GetBookmarkModel();
-  BookmarkNode* node = model->GetMostRecentlyAddedNodeForURL(url_);
+  const BookmarkNode* node = model->GetMostRecentlyAddedNodeForURL(url_);
   if (node) {
     // NOTE: Would be nice to save a strlen and use gtk_entry_get_text_length,
     // but it is fairly new and not always in our GTK version.
@@ -286,7 +286,7 @@ void BookmarkBubbleGtk::ApplyEdits() {
 
     // Last index ('Choose another folder...') is not in folder_nodes_.
     if (cur_folder < folder_nodes_.size()) {
-      BookmarkNode* new_parent = folder_nodes_[cur_folder];
+      const BookmarkNode* new_parent = folder_nodes_[cur_folder];
       if (new_parent != node->GetParent()) {
         UserMetrics::RecordAction(L"BookmarkBubble_ChangeParent", profile_);
         model->Move(node, new_parent, new_parent->GetChildCount());
@@ -297,7 +297,8 @@ void BookmarkBubbleGtk::ApplyEdits() {
 
 std::string BookmarkBubbleGtk::GetTitle() {
   BookmarkModel* bookmark_model= profile_->GetBookmarkModel();
-  BookmarkNode* node = bookmark_model->GetMostRecentlyAddedNodeForURL(url_);
+  const BookmarkNode* node =
+      bookmark_model->GetMostRecentlyAddedNodeForURL(url_);
   if (!node) {
     NOTREACHED();
     return std::string();
@@ -307,7 +308,7 @@ std::string BookmarkBubbleGtk::GetTitle() {
 }
 
 void BookmarkBubbleGtk::ShowEditor() {
-  BookmarkNode* node =
+  const BookmarkNode* node =
       profile_->GetBookmarkModel()->GetMostRecentlyAddedNodeForURL(url_);
 
   // Commit any edits now.
diff --git a/chrome/browser/gtk/bookmark_bubble_gtk.h b/chrome/browser/gtk/bookmark_bubble_gtk.h
index 8e67f6c..48890b6 100644
--- a/chrome/browser/gtk/bookmark_bubble_gtk.h
+++ b/chrome/browser/gtk/bookmark_bubble_gtk.h
@@ -121,7 +121,7 @@ class BookmarkBubbleGtk : public InfoBubbleGtkDelegate {
   GtkWidget* folder_combo_;
 
   // The bookmark nodes in |folder_combo_|.
-  std::vector<BookmarkNode*> folder_nodes_;
+  std::vector<const BookmarkNode*> folder_nodes_;
 
   InfoBubbleGtk* bubble_;
 
diff --git a/chrome/browser/gtk/bookmark_context_menu.cc b/chrome/browser/gtk/bookmark_context_menu.cc
index ff92135..8af8058 100644
--- a/chrome/browser/gtk/bookmark_context_menu.cc
+++ b/chrome/browser/gtk/bookmark_context_menu.cc
@@ -30,7 +30,7 @@ namespace {
 
 // Returns true if the specified node is of type URL, or has a descendant
 // of type URL.
-bool NodeHasURLs(BookmarkNode* node) {
+bool NodeHasURLs(const BookmarkNode* node) {
   if (node->is_url())
     return true;
 
@@ -57,7 +57,7 @@ class EditFolderController : public InputWindowDialog::Delegate,
 
   static void Show(Profile* profile,
                    gfx::NativeView wnd,
-                   BookmarkNode* node,
+                   const BookmarkNode* node,
                    bool is_new,
                    bool show_in_manager) {
     // EditFolderController deletes itself when done.
@@ -69,7 +69,7 @@ class EditFolderController : public InputWindowDialog::Delegate,
  private:
   EditFolderController(Profile* profile,
                        gfx::NativeView wnd,
-                       BookmarkNode* node,
+                       const BookmarkNode* node,
                        bool is_new,
                        bool show_in_manager)
       : profile_(profile),
@@ -103,7 +103,7 @@ class EditFolderController : public InputWindowDialog::Delegate,
 
   virtual void InputAccepted(const std::wstring& text) {
     if (is_new_) {
-      ALLOW_UNUSED BookmarkNode* node =
+      ALLOW_UNUSED const BookmarkNode* node =
           model_->AddGroup(node_, node_->GetChildCount(), text);
       if (show_in_manager_) {
 #if defined(OS_WIN) || (defined(OS_LINUX) && !defined(TOOLKIT_VIEWS))
@@ -130,35 +130,36 @@ class EditFolderController : public InputWindowDialog::Delegate,
   }
 
   virtual void BookmarkNodeMoved(BookmarkModel* model,
-                                 BookmarkNode* old_parent,
+                                 const BookmarkNode* old_parent,
                                  int old_index,
-                                 BookmarkNode* new_parent,
+                                 const BookmarkNode* new_parent,
                                  int new_index) {
     ModelChanged();
   }
 
   virtual void BookmarkNodeAdded(BookmarkModel* model,
-                                 BookmarkNode* parent,
+                                 const BookmarkNode* parent,
                                  int index) {
     ModelChanged();
   }
 
   virtual void BookmarkNodeRemoved(BookmarkModel* model,
-                                   BookmarkNode* parent,
+                                   const BookmarkNode* parent,
                                    int index,
-                                   BookmarkNode* node) {
+                                   const BookmarkNode* node) {
     ModelChanged();
   }
 
-  virtual void BookmarkNodeChanged(BookmarkModel* model, BookmarkNode* node) {
+  virtual void BookmarkNodeChanged(BookmarkModel* model,
+                                   const BookmarkNode* node) {
     ModelChanged();
   }
 
   virtual void BookmarkNodeFavIconLoaded(BookmarkModel* model,
-                                         BookmarkNode* node) {}
+                                         const BookmarkNode* node) {}
 
   virtual void BookmarkNodeChildrenReordered(BookmarkModel* model,
-                                             BookmarkNode* node) {
+                                             const BookmarkNode* node) {
     ModelChanged();
   }
 
@@ -170,7 +171,7 @@ class EditFolderController : public InputWindowDialog::Delegate,
   BookmarkModel* model_;
   // If is_new is true, this is the parent to create the new node under.
   // Otherwise this is the node to change the title of.
-  BookmarkNode* node_;
+  const BookmarkNode* node_;
 
   bool is_new_;
 
@@ -192,7 +193,7 @@ class SelectOnCreationHandler : public BookmarkEditor::Handler {
   explicit SelectOnCreationHandler(Profile* profile) : profile_(profile) {
   }
 
-  virtual void NodeCreated(BookmarkNode* new_node) {
+  virtual void NodeCreated(const BookmarkNode* new_node) {
     BookmarkManager::SelectInTree(profile_, new_node);
   }
 
@@ -212,8 +213,8 @@ BookmarkContextMenu::BookmarkContextMenu(
     Profile* profile,
     Browser* browser,
     PageNavigator* navigator,
-    BookmarkNode* parent,
-    const std::vector<BookmarkNode*>& selection,
+    const BookmarkNode* parent,
+    const std::vector<const BookmarkNode*>& selection,
     ConfigurationType configuration)
     : wnd_(wnd),
       profile_(profile),
@@ -502,33 +503,33 @@ void BookmarkContextMenu::BookmarkModelBeingDeleted(BookmarkModel* model) {
 }
 
 void BookmarkContextMenu::BookmarkNodeMoved(BookmarkModel* model,
-                                            BookmarkNode* old_parent,
+                                            const BookmarkNode* old_parent,
                                             int old_index,
-                                            BookmarkNode* new_parent,
+                                            const BookmarkNode* new_parent,
                                             int new_index) {
   ModelChanged();
 }
 
 void BookmarkContextMenu::BookmarkNodeAdded(BookmarkModel* model,
-                                            BookmarkNode* parent,
+                                            const BookmarkNode* parent,
                                             int index) {
   ModelChanged();
 }
 
 void BookmarkContextMenu::BookmarkNodeRemoved(BookmarkModel* model,
-                                              BookmarkNode* parent,
+                                              const BookmarkNode* parent,
                                               int index,
-                                              BookmarkNode* node) {
+                                              const BookmarkNode* node) {
   ModelChanged();
 }
 
 void BookmarkContextMenu::BookmarkNodeChanged(BookmarkModel* model,
-                                              BookmarkNode* node) {
+                                              const BookmarkNode* node) {
   ModelChanged();
 }
 
-void BookmarkContextMenu::BookmarkNodeChildrenReordered(BookmarkModel* model,
-                                                        BookmarkNode* node) {
+void BookmarkContextMenu::BookmarkNodeChildrenReordered(
+    BookmarkModel* model, const BookmarkNode* node) {
   ModelChanged();
 }
 
@@ -551,7 +552,7 @@ bool BookmarkContextMenu::HasURLs() const {
   return false;
 }
 
-BookmarkNode* BookmarkContextMenu::GetParentForNewNodes() const {
+const BookmarkNode* BookmarkContextMenu::GetParentForNewNodes() const {
   return (selection_.size() == 1 && selection_[0]->is_folder()) ?
       selection_[0] : parent_;
 }
diff --git a/chrome/browser/gtk/bookmark_context_menu.h b/chrome/browser/gtk/bookmark_context_menu.h
index 38dc37a..db601c9 100644
--- a/chrome/browser/gtk/bookmark_context_menu.h
+++ b/chrome/browser/gtk/bookmark_context_menu.h
@@ -59,8 +59,8 @@ class BookmarkContextMenu : public BookmarkModelObserver,
                       Profile* profile,
                       Browser* browser,
                       PageNavigator* navigator,
-                      BookmarkNode* parent,
-                      const std::vector<BookmarkNode*>& selection,
+                      const BookmarkNode* parent,
+                      const std::vector<const BookmarkNode*>& selection,
                       ConfigurationType configuration);
   virtual ~BookmarkContextMenu();
 
@@ -89,23 +89,23 @@ class BookmarkContextMenu : public BookmarkModelObserver,
   virtual void Loaded(BookmarkModel* model) {}
   virtual void BookmarkModelBeingDeleted(BookmarkModel* model);
   virtual void BookmarkNodeMoved(BookmarkModel* model,
-                                 BookmarkNode* old_parent,
+                                 const BookmarkNode* old_parent,
                                  int old_index,
-                                 BookmarkNode* new_parent,
+                                 const BookmarkNode* new_parent,
                                  int new_index);
   virtual void BookmarkNodeAdded(BookmarkModel* model,
-                                 BookmarkNode* parent,
+                                 const BookmarkNode* parent,
                                  int index);
   virtual void BookmarkNodeRemoved(BookmarkModel* model,
-                                   BookmarkNode* parent,
+                                   const BookmarkNode* parent,
                                    int index,
-                                   BookmarkNode* node);
+                                   const BookmarkNode* node);
   virtual void BookmarkNodeChanged(BookmarkModel* model,
-                                   BookmarkNode* node);
+                                   const BookmarkNode* node);
   virtual void BookmarkNodeFavIconLoaded(BookmarkModel* model,
-                                         BookmarkNode* node) {}
+                                         const BookmarkNode* node) {}
   virtual void BookmarkNodeChildrenReordered(BookmarkModel* model,
-                                             BookmarkNode* node);
+                                             const BookmarkNode* node);
 
   // Invoked from the various bookmark model observer methods. Closes the menu.
   void ModelChanged();
@@ -131,14 +131,14 @@ class BookmarkContextMenu : public BookmarkModelObserver,
   // Returns the parent for newly created folders/bookmarks. If selection_
   // has one element and it is a folder, selection_[0] is returned, otherwise
   // parent_ is returned.
-  BookmarkNode* GetParentForNewNodes() const;
+  const BookmarkNode* GetParentForNewNodes() const;
 
   gfx::NativeView wnd_;
   Profile* profile_;
   Browser* browser_;
   PageNavigator* navigator_;
-  BookmarkNode* parent_;
-  std::vector<BookmarkNode*> selection_;
+  const BookmarkNode* parent_;
+  std::vector<const BookmarkNode*> selection_;
   BookmarkModel* model_;
   ConfigurationType configuration_;
 
diff --git a/chrome/browser/gtk/bookmark_editor_gtk.cc b/chrome/browser/gtk/bookmark_editor_gtk.cc
index 05d1ec2..1a6171c 100644
--- a/chrome/browser/gtk/bookmark_editor_gtk.cc
+++ b/chrome/browser/gtk/bookmark_editor_gtk.cc
@@ -37,8 +37,8 @@ static const int kTreeHeight = 150;
 // static
 void BookmarkEditor::Show(gfx::NativeView parent_hwnd,
                           Profile* profile,
-                          BookmarkNode* parent,
-                          BookmarkNode* node,
+                          const BookmarkNode* parent,
+                          const BookmarkNode* node,
                           Configuration configuration,
                           Handler* handler) {
   DCHECK(profile);
@@ -51,8 +51,8 @@ void BookmarkEditor::Show(gfx::NativeView parent_hwnd,
 BookmarkEditorGtk::BookmarkEditorGtk(
     GtkWindow* window,
     Profile* profile,
-    BookmarkNode* parent,
-    BookmarkNode* node,
+    const BookmarkNode* parent,
+    const BookmarkNode* node,
     BookmarkEditor::Configuration configuration,
     BookmarkEditor::Handler* handler)
     : profile_(profile),
@@ -228,23 +228,23 @@ void BookmarkEditorGtk::Close() {
 }
 
 void BookmarkEditorGtk::BookmarkNodeMoved(BookmarkModel* model,
-                                          BookmarkNode* old_parent,
+                                          const BookmarkNode* old_parent,
                                           int old_index,
-                                          BookmarkNode* new_parent,
+                                          const BookmarkNode* new_parent,
                                           int new_index) {
   Reset();
 }
 
 void BookmarkEditorGtk::BookmarkNodeAdded(BookmarkModel* model,
-                                          BookmarkNode* parent,
+                                          const BookmarkNode* parent,
                                           int index) {
   Reset();
 }
 
 void BookmarkEditorGtk::BookmarkNodeRemoved(BookmarkModel* model,
-                                            BookmarkNode* parent,
+                                            const BookmarkNode* parent,
                                             int index,
-                                            BookmarkNode* node) {
+                                            const BookmarkNode* node) {
   if ((node_ && node_->HasAncestor(node)) ||
       (parent_ && parent_->HasAncestor(node))) {
     // The node, or its parent was removed. Close the dialog.
@@ -254,8 +254,8 @@ void BookmarkEditorGtk::BookmarkNodeRemoved(BookmarkModel* model,
   }
 }
 
-void BookmarkEditorGtk::BookmarkNodeChildrenReordered(BookmarkModel* model,
-                                                      BookmarkNode* node) {
+void BookmarkEditorGtk::BookmarkNodeChildrenReordered(
+    BookmarkModel* model, const BookmarkNode* node) {
   Reset();
 }
 
@@ -306,7 +306,8 @@ void BookmarkEditorGtk::ApplyEdits(GtkTreeIter* selected_parent) {
   }
 
   // Create the new groups and update the titles.
-  BookmarkNode* new_parent = bookmark_utils::CommitTreeStoreDifferencesBetween(
+  const BookmarkNode* new_parent =
+      bookmark_utils::CommitTreeStoreDifferencesBetween(
       bb_model_, tree_store_, selected_parent);
 
   if (!new_parent) {
diff --git a/chrome/browser/gtk/bookmark_editor_gtk.h b/chrome/browser/gtk/bookmark_editor_gtk.h
index 4149a05..70ed8c4 100644
--- a/chrome/browser/gtk/bookmark_editor_gtk.h
+++ b/chrome/browser/gtk/bookmark_editor_gtk.h
@@ -26,8 +26,8 @@ class BookmarkEditorGtk : public BookmarkEditor,
  public:
   BookmarkEditorGtk(GtkWindow* window,
                     Profile* profile,
-                    BookmarkNode* parent,
-                    BookmarkNode* node,
+                    const BookmarkNode* parent,
+                    const BookmarkNode* node,
                     BookmarkEditor::Configuration configuration,
                     BookmarkEditor::Handler* handler);
 
@@ -43,23 +43,23 @@ class BookmarkEditorGtk : public BookmarkEditor,
   // resetting the tree model.
   virtual void Loaded(BookmarkModel* model) { }
   virtual void BookmarkNodeMoved(BookmarkModel* model,
-                                 BookmarkNode* old_parent,
+                                 const BookmarkNode* old_parent,
                                  int old_index,
-                                 BookmarkNode* new_parent,
+                                 const BookmarkNode* new_parent,
                                  int new_index);
   virtual void BookmarkNodeAdded(BookmarkModel* model,
-                                 BookmarkNode* parent,
+                                 const BookmarkNode* parent,
                                  int index);
   virtual void BookmarkNodeRemoved(BookmarkModel* model,
-                                   BookmarkNode* parent,
+                                   const BookmarkNode* parent,
                                    int index,
-                                   BookmarkNode* node);
+                                   const BookmarkNode* node);
   virtual void BookmarkNodeChanged(BookmarkModel* model,
-                                   BookmarkNode* node) {}
+                                   const BookmarkNode* node) {}
   virtual void BookmarkNodeChildrenReordered(BookmarkModel* model,
-                                             BookmarkNode* node);
+                                             const BookmarkNode* node);
   virtual void BookmarkNodeFavIconLoaded(BookmarkModel* model,
-                                         BookmarkNode* node) {}
+                                         const BookmarkNode* node) {}
 
   // Resets the model of the tree and updates the various buttons appropriately.
   void Reset();
@@ -117,10 +117,10 @@ class BookmarkEditorGtk : public BookmarkEditor,
   // that into a GObject that implements the interface GtkTreeModel.
 
   // Initial parent to select. Is only used if node_ is NULL.
-  BookmarkNode* parent_;
+  const BookmarkNode* parent_;
 
   // Node being edited. Is NULL if creating a new node.
-  BookmarkNode* node_;
+  const BookmarkNode* node_;
 
   // Mode used to create nodes from.
   BookmarkModel* bb_model_;
diff --git a/chrome/browser/gtk/bookmark_editor_gtk_unittest.cc b/chrome/browser/gtk/bookmark_editor_gtk_unittest.cc
index ccbd033..7cb3a44 100644
--- a/chrome/browser/gtk/bookmark_editor_gtk_unittest.cc
+++ b/chrome/browser/gtk/bookmark_editor_gtk_unittest.cc
@@ -48,7 +48,7 @@ class BookmarkEditorGtkTest : public testing::Test {
 
   std::string base_path() const { return "file:///c:/tmp/"; }
 
-  BookmarkNode* GetNode(const std::string& name) {
+  const BookmarkNode* GetNode(const std::string& name) {
     return model_->GetMostRecentlyAddedNodeForURL(GURL(base_path() + name));
   }
 
@@ -70,16 +70,18 @@ class BookmarkEditorGtkTest : public testing::Test {
 
     model_->AddURL(model_->GetBookmarkBarNode(), 0, L"a",
                    GURL(test_base + "a"));
-    BookmarkNode* f1 = model_->AddGroup(model_->GetBookmarkBarNode(), 1, L"F1");
+    const BookmarkNode* f1 =
+        model_->AddGroup(model_->GetBookmarkBarNode(), 1, L"F1");
     model_->AddURL(f1, 0, L"f1a", GURL(test_base + "f1a"));
-    BookmarkNode* f11 = model_->AddGroup(f1, 1, L"F11");
+    const BookmarkNode* f11 = model_->AddGroup(f1, 1, L"F11");
     model_->AddURL(f11, 0, L"f11a", GURL(test_base + "f11a"));
     model_->AddGroup(model_->GetBookmarkBarNode(), 2, L"F2");
 
     // Children of the other node.
     model_->AddURL(model_->other_node(), 0, L"oa",
                    GURL(test_base + "oa"));
-    BookmarkNode* of1 = model_->AddGroup(model_->other_node(), 1, L"OF1");
+    const BookmarkNode* of1 =
+        model_->AddGroup(model_->other_node(), 1, L"OF1");
     model_->AddURL(of1, 0, L"of1a", GURL(test_base + "of1a"));
   }
 };
@@ -134,7 +136,8 @@ TEST_F(BookmarkEditorGtkTest, EditTitleKeepsPosition) {
   ASSERT_TRUE(gtk_tree_model_get_iter_first(store, &bookmark_bar_node));
   editor.ApplyEdits(&bookmark_bar_node);
 
-  BookmarkNode* bb_node = profile_->GetBookmarkModel()->GetBookmarkBarNode();
+  const BookmarkNode* bb_node =
+      profile_->GetBookmarkModel()->GetBookmarkBarNode();
   ASSERT_EQ(L"new_a", bb_node->GetChild(0)->GetTitle());
   // The URL shouldn't have changed.
   ASSERT_TRUE(GURL(base_path() + "a") == bb_node->GetChild(0)->GetURL());
@@ -142,8 +145,7 @@ TEST_F(BookmarkEditorGtkTest, EditTitleKeepsPosition) {
 
 // Changes the url and makes sure parent/visual order doesn't change.
 TEST_F(BookmarkEditorGtkTest, EditURLKeepsPosition) {
-  Time node_time = Time::Now() + TimeDelta::FromDays(2);
-  GetNode("a")->date_added_ = node_time;
+  Time node_time = GetNode("a")->date_added();
   BookmarkEditorGtk editor(NULL, profile_.get(), NULL, GetNode("a"),
                            BookmarkEditor::SHOW_TREE, NULL);
   gtk_entry_set_text(GTK_ENTRY(editor.url_entry_),
@@ -154,7 +156,8 @@ TEST_F(BookmarkEditorGtkTest, EditURLKeepsPosition) {
   ASSERT_TRUE(gtk_tree_model_get_iter_first(store, &bookmark_bar_node));
   editor.ApplyEdits(&bookmark_bar_node);
 
-  BookmarkNode* bb_node = profile_->GetBookmarkModel()->GetBookmarkBarNode();
+  const BookmarkNode* bb_node =
+      profile_->GetBookmarkModel()->GetBookmarkBarNode();
   ASSERT_EQ(L"a", bb_node->GetChild(0)->GetTitle());
   // The URL should have changed.
   ASSERT_TRUE(GURL(base_path() + "new_a") == bb_node->GetChild(0)->GetURL());
@@ -172,7 +175,7 @@ TEST_F(BookmarkEditorGtkTest, ChangeParent) {
   ASSERT_TRUE(gtk_tree_model_iter_next(store, &gtk_other_node));
   editor.ApplyEdits(&gtk_other_node);
 
-  BookmarkNode* other_node = profile_->GetBookmarkModel()->other_node();
+  const BookmarkNode* other_node = profile_->GetBookmarkModel()->other_node();
   ASSERT_EQ(L"a", other_node->GetChild(2)->GetTitle());
   ASSERT_TRUE(GURL(base_path() + "a") == other_node->GetChild(2)->GetURL());
 }
@@ -180,8 +183,7 @@ TEST_F(BookmarkEditorGtkTest, ChangeParent) {
 // Moves 'a' to be a child of the other node.
 // Moves 'a' to be a child of the other node and changes its url to new_a.
 TEST_F(BookmarkEditorGtkTest, ChangeParentAndURL) {
-  Time node_time = Time::Now() + TimeDelta::FromDays(2);
-  GetNode("a")->date_added_ = node_time;
+  Time node_time = GetNode("a")->date_added();
   BookmarkEditorGtk editor(NULL, profile_.get(), NULL, GetNode("a"),
                            BookmarkEditor::SHOW_TREE, NULL);
 
@@ -194,7 +196,7 @@ TEST_F(BookmarkEditorGtkTest, ChangeParentAndURL) {
   ASSERT_TRUE(gtk_tree_model_iter_next(store, &gtk_other_node));
   editor.ApplyEdits(&gtk_other_node);
 
-  BookmarkNode* other_node = profile_->GetBookmarkModel()->other_node();
+  const BookmarkNode* other_node = profile_->GetBookmarkModel()->other_node();
   ASSERT_EQ(L"a", other_node->GetChild(2)->GetTitle());
   ASSERT_TRUE(GURL(base_path() + "new_a") == other_node->GetChild(2)->GetURL());
   ASSERT_TRUE(node_time == other_node->GetChild(2)->date_added());
@@ -230,8 +232,9 @@ TEST_F(BookmarkEditorGtkTest, MoveToNewParent) {
 
   editor.ApplyEdits(&f2_iter);
 
-  BookmarkNode* bb_node = profile_->GetBookmarkModel()->GetBookmarkBarNode();
-  BookmarkNode* mf2 = bb_node->GetChild(1);
+  const BookmarkNode* bb_node =
+      profile_->GetBookmarkModel()->GetBookmarkBarNode();
+  const BookmarkNode* mf2 = bb_node->GetChild(1);
 
   // F2 in the model should have two children now: F21 and the node edited.
   ASSERT_EQ(2, mf2->GetChildCount());
@@ -241,7 +244,7 @@ TEST_F(BookmarkEditorGtkTest, MoveToNewParent) {
   ASSERT_EQ(L"a", mf2->GetChild(1)->GetTitle());
 
   // F21 should have one child, F211.
-  BookmarkNode* mf21 = mf2->GetChild(0);
+  const BookmarkNode* mf21 = mf2->GetChild(0);
   ASSERT_EQ(1, mf21->GetChildCount());
   ASSERT_EQ(L"F211", mf21->GetChild(0)->GetTitle());
 }
@@ -260,10 +263,11 @@ TEST_F(BookmarkEditorGtkTest, NewURL) {
   ASSERT_TRUE(gtk_tree_model_get_iter_first(store, &bookmark_bar_node));
   editor.ApplyEdits(&bookmark_bar_node);
 
-  BookmarkNode* bb_node = profile_->GetBookmarkModel()->GetBookmarkBarNode();
+  const BookmarkNode* bb_node =
+      profile_->GetBookmarkModel()->GetBookmarkBarNode();
   ASSERT_EQ(4, bb_node->GetChildCount());
 
-  BookmarkNode* new_node = bb_node->GetChild(3);
+  const BookmarkNode* new_node = bb_node->GetChild(3);
   EXPECT_EQ(L"new_a", new_node->GetTitle());
   EXPECT_TRUE(GURL(base_path() + "a") == new_node->GetURL());
 }
@@ -280,10 +284,10 @@ TEST_F(BookmarkEditorGtkTest, ChangeURLNoTree) {
 
   editor.ApplyEdits(NULL);
 
-  BookmarkNode* other_node = profile_->GetBookmarkModel()->other_node();
+  const BookmarkNode* other_node = profile_->GetBookmarkModel()->other_node();
   ASSERT_EQ(2, other_node->GetChildCount());
 
-  BookmarkNode* new_node = other_node->GetChild(0);
+  const BookmarkNode* new_node = other_node->GetChild(0);
 
   EXPECT_EQ(L"new_a", new_node->GetTitle());
   EXPECT_TRUE(GURL(base_path() + "a") == new_node->GetURL());
@@ -298,9 +302,9 @@ TEST_F(BookmarkEditorGtkTest, ChangeTitleNoTree) {
 
   editor.ApplyEdits();
 
-  BookmarkNode* other_node = profile_->GetBookmarkModel()->other_node();
+  const BookmarkNode* other_node = profile_->GetBookmarkModel()->other_node();
   ASSERT_EQ(2, other_node->GetChildCount());
 
-  BookmarkNode* new_node = other_node->GetChild(0);
+  const BookmarkNode* new_node = other_node->GetChild(0);
   EXPECT_EQ(L"new_a", new_node->GetTitle());
 }
diff --git a/chrome/browser/gtk/bookmark_manager_gtk.cc b/chrome/browser/gtk/bookmark_manager_gtk.cc
index fca5f1f..b1db3ad 100644
--- a/chrome/browser/gtk/bookmark_manager_gtk.cc
+++ b/chrome/browser/gtk/bookmark_manager_gtk.cc
@@ -72,7 +72,7 @@ class ImportObserverImpl : public ImportObserver {
     BookmarkModel* model = profile_->GetBookmarkModel();
     int other_count = model->other_node()->GetChildCount();
     if (other_count == initial_other_count_ + 1) {
-      BookmarkNode* imported_node =
+      const BookmarkNode* imported_node =
           model->other_node()->GetChild(initial_other_count_);
       manager->SelectInTree(imported_node, true);
     }
@@ -112,7 +112,7 @@ void SetMenuBarStyle() {
 
 // BookmarkManager -------------------------------------------------------------
 
-void BookmarkManager::SelectInTree(Profile* profile, BookmarkNode* node) {
+void BookmarkManager::SelectInTree(Profile* profile, const BookmarkNode* node) {
   if (manager && manager->profile() == profile)
     manager->SelectInTree(node, false);
 }
@@ -123,7 +123,7 @@ void BookmarkManager::Show(Profile* profile) {
 
 // BookmarkManagerGtk, public --------------------------------------------------
 
-void BookmarkManagerGtk::SelectInTree(BookmarkNode* node, bool expand) {
+void BookmarkManagerGtk::SelectInTree(const BookmarkNode* node, bool expand) {
   GtkTreeIter iter = { 0, };
   if (RecursiveFind(GTK_TREE_MODEL(left_store_), &iter, node->id())) {
     GtkTreePath* path = gtk_tree_model_get_path(GTK_TREE_MODEL(left_store_),
@@ -160,9 +160,9 @@ void BookmarkManagerGtk::BookmarkModelBeingDeleted(BookmarkModel* model) {
 }
 
 void BookmarkManagerGtk::BookmarkNodeMoved(BookmarkModel* model,
-                                           BookmarkNode* old_parent,
+                                           const BookmarkNode* old_parent,
                                            int old_index,
-                                           BookmarkNode* new_parent,
+                                           const BookmarkNode* new_parent,
                                            int new_index) {
   BookmarkNodeRemoved(model, old_parent, old_index,
                       new_parent->GetChild(new_index));
@@ -170,9 +170,9 @@ void BookmarkManagerGtk::BookmarkNodeMoved(BookmarkModel* model,
 }
 
 void BookmarkManagerGtk::BookmarkNodeAdded(BookmarkModel* model,
-                                           BookmarkNode* parent,
+                                           const BookmarkNode* parent,
                                            int index) {
-  BookmarkNode* node = parent->GetChild(index);
+  const BookmarkNode* node = parent->GetChild(index);
   if (node->is_folder()) {
     GtkTreeIter iter = { 0, };
     if (RecursiveFind(GTK_TREE_MODEL(left_store_), &iter, parent->id()))
@@ -181,15 +181,15 @@ void BookmarkManagerGtk::BookmarkNodeAdded(BookmarkModel* model,
 }
 
 void BookmarkManagerGtk::BookmarkNodeRemoved(BookmarkModel* model,
-                                             BookmarkNode* parent,
+                                             const BookmarkNode* parent,
                                              int index) {
   NOTREACHED();
 }
 
 void BookmarkManagerGtk::BookmarkNodeRemoved(BookmarkModel* model,
-                                             BookmarkNode* parent,
+                                             const BookmarkNode* parent,
                                              int old_index,
-                                             BookmarkNode* node) {
+                                             const BookmarkNode* node) {
   if (node->is_folder()) {
     GtkTreeIter iter = { 0, };
     if (RecursiveFind(GTK_TREE_MODEL(left_store_), &iter, node->id())) {
@@ -207,17 +207,17 @@ void BookmarkManagerGtk::BookmarkNodeRemoved(BookmarkModel* model,
 }
 
 void BookmarkManagerGtk::BookmarkNodeChanged(BookmarkModel* model,
-                                             BookmarkNode* node) {
+                                             const BookmarkNode* node) {
   // TODO(estade): rename in the left tree view.
 }
 
-void BookmarkManagerGtk::BookmarkNodeChildrenReordered(BookmarkModel* model,
-                                                       BookmarkNode* node) {
+void BookmarkManagerGtk::BookmarkNodeChildrenReordered(
+    BookmarkModel* model, const BookmarkNode* node) {
   // TODO(estade): reorder in the left tree view.
 }
 
 void BookmarkManagerGtk::BookmarkNodeFavIconLoaded(BookmarkModel* model,
-                                                   BookmarkNode* node) {
+                                                   const BookmarkNode* node) {
   // I don't think we have anything to do, as we should never get this for a
   // folder node and we handle it via OnItemsChanged for any URL node.
 }
@@ -473,8 +473,8 @@ GtkWidget* BookmarkManagerGtk::MakeRightPane() {
 
 void BookmarkManagerGtk::ResetOrganizeMenu(bool left) {
   organize_is_for_left_ = left;
-  BookmarkNode* parent = GetFolder();
-  std::vector<BookmarkNode*> nodes;
+  const BookmarkNode* parent = GetFolder();
+  std::vector<const BookmarkNode*> nodes;
   if (!left)
     nodes = GetRightSelection();
   else if (parent)
@@ -520,7 +520,7 @@ void BookmarkManagerGtk::BuildLeftStore() {
 }
 
 void BookmarkManagerGtk::BuildRightStore() {
-  BookmarkNode* node = GetFolder();
+  const BookmarkNode* node = GetFolder();
 
   gtk_list_store_clear(right_store_);
 
@@ -574,8 +574,8 @@ int BookmarkManagerGtk::GetRowIDAt(GtkTreeModel* model, GtkTreeIter* iter) {
   return id;
 }
 
-BookmarkNode* BookmarkManagerGtk::GetNodeAt(GtkTreeModel* model,
-                                            GtkTreeIter* iter) {
+const BookmarkNode* BookmarkManagerGtk::GetNodeAt(GtkTreeModel* model,
+                                                  GtkTreeIter* iter) {
   int id = GetRowIDAt(model, iter);
   if (id > 0)
     return model_->GetNodeByID(id);
@@ -583,7 +583,7 @@ BookmarkNode* BookmarkManagerGtk::GetNodeAt(GtkTreeModel* model,
     return NULL;
 }
 
-BookmarkNode* BookmarkManagerGtk::GetFolder() {
+const BookmarkNode* BookmarkManagerGtk::GetFolder() {
   GtkTreeModel* model;
   GtkTreeIter iter;
   if (!gtk_tree_selection_get_selected(left_selection(), &model, &iter))
@@ -598,11 +598,11 @@ int BookmarkManagerGtk::GetSelectedRowID() {
   return GetRowIDAt(model, &iter);
 }
 
-std::vector<BookmarkNode*> BookmarkManagerGtk::GetRightSelection() {
+std::vector<const BookmarkNode*> BookmarkManagerGtk::GetRightSelection() {
   GtkTreeModel* model;
   GList* paths = gtk_tree_selection_get_selected_rows(right_selection(),
                                                       &model);
-  std::vector<BookmarkNode*> nodes;
+  std::vector<const BookmarkNode*> nodes;
   for (GList* item = paths; item; item = item->next) {
     GtkTreeIter iter;
     gtk_tree_model_get_iter(model, &iter,
@@ -617,7 +617,7 @@ std::vector<BookmarkNode*> BookmarkManagerGtk::GetRightSelection() {
 void BookmarkManagerGtk::SetRightSideColumnValues(int row, GtkTreeIter* iter) {
   // TODO(estade): building the path could be optimized out when we aren't
   // showing the path column.
-  BookmarkNode* node = right_tree_model_->GetNodeForRow(row);
+  const BookmarkNode* node = right_tree_model_->GetNodeForRow(row);
   GdkPixbuf* pixbuf = bookmark_utils::GetPixbufForNode(node, model_);
   std::wstring title =
       right_tree_model_->GetText(row, IDS_BOOKMARK_TABLE_TITLE);
@@ -742,7 +742,7 @@ void BookmarkManagerGtk::OnLeftTreeViewDragReceived(
   gboolean dnd_success = FALSE;
   gboolean delete_selection_data = FALSE;
 
-  std::vector<BookmarkNode*> nodes =
+  std::vector<const BookmarkNode*> nodes =
       bookmark_utils::GetNodesFromSelection(context, selection_data,
                                             target_type,
                                             bm->profile_,
@@ -765,8 +765,9 @@ void BookmarkManagerGtk::OnLeftTreeViewDragReceived(
 
   GtkTreeIter iter;
   gtk_tree_model_get_iter(GTK_TREE_MODEL(bm->left_store_), &iter, path);
-  BookmarkNode* folder = bm->GetNodeAt(GTK_TREE_MODEL(bm->left_store_), &iter);
-  for (std::vector<BookmarkNode*>::iterator it = nodes.begin();
+  const BookmarkNode* folder = bm->GetNodeAt(
+      GTK_TREE_MODEL(bm->left_store_), &iter);
+  for (std::vector<const BookmarkNode*>::iterator it = nodes.begin();
        it != nodes.end(); ++it) {
     // Don't try to drop a node into one of its descendants.
     if (!folder->HasAncestor(*it))
@@ -836,7 +837,7 @@ void BookmarkManagerGtk::OnRightTreeViewDragReceived(
   gboolean dnd_success = FALSE;
   gboolean delete_selection_data = FALSE;
 
-  std::vector<BookmarkNode*> nodes =
+  std::vector<const BookmarkNode*> nodes =
       bookmark_utils::GetNodesFromSelection(context, selection_data,
                                             target_type,
                                             bm->profile_,
@@ -857,7 +858,7 @@ void BookmarkManagerGtk::OnRightTreeViewDragReceived(
   bool drop_after = pos == GTK_TREE_VIEW_DROP_AFTER;
 
   // The parent folder and index therein to drop the nodes.
-  BookmarkNode* parent = NULL;
+  const BookmarkNode* parent = NULL;
   int idx = -1;
 
   // |path| will be null when we are looking at an empty folder.
@@ -865,7 +866,7 @@ void BookmarkManagerGtk::OnRightTreeViewDragReceived(
     GtkTreeIter iter;
     GtkTreeModel* model = GTK_TREE_MODEL(bm->right_store_);
     gtk_tree_model_get_iter(model, &iter, path);
-    BookmarkNode* node = bm->GetNodeAt(model, &iter);
+    const BookmarkNode* node = bm->GetNodeAt(model, &iter);
     if (node->is_folder()) {
       parent = node;
       idx = parent->GetChildCount();
@@ -883,7 +884,7 @@ void BookmarkManagerGtk::OnRightTreeViewDragReceived(
     idx = !path ? parent->GetChildCount() : gtk_tree_path_get_indices(path)[0];
   }
 
-  for (std::vector<BookmarkNode*>::iterator it = nodes.begin();
+  for (std::vector<const BookmarkNode*>::iterator it = nodes.begin();
        it != nodes.end(); ++it) {
     // Don't try to drop a node into one of its descendants.
     if (!parent->HasAncestor(*it)) {
@@ -913,7 +914,7 @@ gboolean BookmarkManagerGtk::OnRightTreeViewDragMotion(
   gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW(tree_view), x, y,
                                     &path, &pos);
 
-  BookmarkNode* parent = bm->GetFolder();
+  const BookmarkNode* parent = bm->GetFolder();
   if (path) {
     int idx =
         gtk_tree_path_get_indices(path)[gtk_tree_path_get_depth(path) - 1];
@@ -937,7 +938,7 @@ gboolean BookmarkManagerGtk::OnRightTreeViewDragMotion(
 // static
 void BookmarkManagerGtk::OnRightTreeViewRowActivated(GtkTreeView* tree_view,
     GtkTreePath* path, GtkTreeViewColumn* column, BookmarkManagerGtk* bm) {
-  std::vector<BookmarkNode*> nodes = bm->GetRightSelection();
+  std::vector<const BookmarkNode*> nodes = bm->GetRightSelection();
   if (nodes.empty())
     return;
   if (nodes.size() == 1 && nodes[0]->is_folder()) {
diff --git a/chrome/browser/gtk/bookmark_manager_gtk.h b/chrome/browser/gtk/bookmark_manager_gtk.h
index 1ef9041..64586b1 100644
--- a/chrome/browser/gtk/bookmark_manager_gtk.h
+++ b/chrome/browser/gtk/bookmark_manager_gtk.h
@@ -28,7 +28,7 @@ class BookmarkManagerGtk : public BookmarkModelObserver,
   Profile* profile() { return profile_; }
 
   // Show the node in the tree.
-  void SelectInTree(BookmarkNode* node, bool expand);
+  void SelectInTree(const BookmarkNode* node, bool expand);
 
   // Shows the bookmark manager. Only one bookmark manager exists.
   static void Show(Profile* profile);
@@ -39,26 +39,26 @@ class BookmarkManagerGtk : public BookmarkModelObserver,
   virtual void Loaded(BookmarkModel* model);
   virtual void BookmarkModelBeingDeleted(BookmarkModel* model);
   virtual void BookmarkNodeMoved(BookmarkModel* model,
-                                 BookmarkNode* old_parent,
+                                 const BookmarkNode* old_parent,
                                  int old_index,
-                                 BookmarkNode* new_parent,
+                                 const BookmarkNode* new_parent,
                                  int new_index);
   virtual void BookmarkNodeAdded(BookmarkModel* model,
-                                 BookmarkNode* parent,
+                                 const BookmarkNode* parent,
                                  int index);
   virtual void BookmarkNodeRemoved(BookmarkModel* model,
-                                   BookmarkNode* parent,
+                                   const BookmarkNode* parent,
                                    int index);
   virtual void BookmarkNodeRemoved(BookmarkModel* model,
-                                   BookmarkNode* parent,
+                                   const BookmarkNode* parent,
                                    int old_index,
-                                   BookmarkNode* node);
+                                   const BookmarkNode* node);
   virtual void BookmarkNodeChanged(BookmarkModel* model,
-                                   BookmarkNode* node);
+                                   const BookmarkNode* node);
   virtual void BookmarkNodeChildrenReordered(BookmarkModel* model,
-                                             BookmarkNode* node);
+                                             const BookmarkNode* node);
   virtual void BookmarkNodeFavIconLoaded(BookmarkModel* model,
-                                         BookmarkNode* node);
+                                         const BookmarkNode* node);
 
   // TableModelObserver implementation.
   virtual void OnModelChanged();
@@ -93,16 +93,16 @@ class BookmarkManagerGtk : public BookmarkModelObserver,
 
   // Get the node from |model| at |iter|. If the item is not a node, return
   // NULL.
-  BookmarkNode* GetNodeAt(GtkTreeModel* model, GtkTreeIter* iter);
+  const BookmarkNode* GetNodeAt(GtkTreeModel* model, GtkTreeIter* iter);
 
   // Get the node that is selected in the left tree view.
-  BookmarkNode* GetFolder();
+  const BookmarkNode* GetFolder();
 
   // Get the ID of the selected row.
   int GetSelectedRowID();
 
   // Get the nodes that are selected in the right tree view.
-  std::vector<BookmarkNode*> GetRightSelection();
+  std::vector<const BookmarkNode*> GetRightSelection();
 
   // Set the fields for a row.
   void SetRightSideColumnValues(int row, GtkTreeIter* iter);
diff --git a/chrome/browser/gtk/bookmark_menu_controller_gtk.cc b/chrome/browser/gtk/bookmark_menu_controller_gtk.cc
index 68b4ffdf..a0d905b 100644
--- a/chrome/browser/gtk/bookmark_menu_controller_gtk.cc
+++ b/chrome/browser/gtk/bookmark_menu_controller_gtk.cc
@@ -29,18 +29,22 @@ void SetImageMenuItem(GtkWidget* menu_item, const SkBitmap& bitmap) {
   g_object_unref(pixbuf);
 }
 
-BookmarkNode* GetNodeFromMenuItem(GtkWidget* menu_item) {
-  return static_cast<BookmarkNode*>(
+const BookmarkNode* GetNodeFromMenuItem(GtkWidget* menu_item) {
+  return static_cast<const BookmarkNode*>(
       g_object_get_data(G_OBJECT(menu_item), "bookmark-node"));
 }
 
+void* AsVoid(const BookmarkNode* node) {
+  return const_cast<BookmarkNode*>(node);
+}
+
 }  // namespace
 
 BookmarkMenuController::BookmarkMenuController(Browser* browser,
                                                Profile* profile,
                                                PageNavigator* navigator,
                                                GtkWindow* window,
-                                               BookmarkNode* node,
+                                               const BookmarkNode* node,
                                                int start_child_index,
                                                bool show_other_folder)
     : browser_(browser),
@@ -71,9 +75,9 @@ void BookmarkMenuController::BookmarkModelChanged() {
   gtk_menu_popdown(GTK_MENU(menu_.get()));
 }
 
-void BookmarkMenuController::BookmarkNodeFavIconLoaded(BookmarkModel* model,
-                                                       BookmarkNode* node) {
-  std::map<BookmarkNode*, GtkWidget*>::iterator it =
+void BookmarkMenuController::BookmarkNodeFavIconLoaded(
+    BookmarkModel* model, const BookmarkNode* node) {
+  std::map<const BookmarkNode*, GtkWidget*>::iterator it =
       node_to_menu_widget_map_.find(node);
   if (it != node_to_menu_widget_map_.end())
     SetImageMenuItem(it->second, model->GetFavIcon(node));
@@ -82,20 +86,20 @@ void BookmarkMenuController::BookmarkNodeFavIconLoaded(BookmarkModel* model,
 void BookmarkMenuController::NavigateToMenuItem(
     GtkWidget* menu_item,
     WindowOpenDisposition disposition) {
-  BookmarkNode* node = GetNodeFromMenuItem(menu_item);
+  const BookmarkNode* node = GetNodeFromMenuItem(menu_item);
   DCHECK(node);
   DCHECK(page_navigator_);
   page_navigator_->OpenURL(
       node->GetURL(), GURL(), disposition, PageTransition::AUTO_BOOKMARK);
 }
 
-void BookmarkMenuController::BuildMenu(BookmarkNode* parent,
+void BookmarkMenuController::BuildMenu(const BookmarkNode* parent,
                                        int start_child_index,
                                        GtkWidget* menu) {
   DCHECK(!parent->GetChildCount() ||
          start_child_index < parent->GetChildCount());
   for (int i = start_child_index; i < parent->GetChildCount(); ++i) {
-    BookmarkNode* node = parent->GetChild(i);
+    const BookmarkNode* node = parent->GetChild(i);
 
     GtkWidget* menu_item = gtk_image_menu_item_new_with_label(
         WideToUTF8(node->GetTitle()).c_str());
@@ -107,7 +111,7 @@ void BookmarkMenuController::BuildMenu(BookmarkNode* parent,
             GetBitmapNamed(IDR_DEFAULT_FAVICON);
       }
       SetImageMenuItem(menu_item, icon);
-      g_object_set_data(G_OBJECT(menu_item), "bookmark-node", node);
+      g_object_set_data(G_OBJECT(menu_item), "bookmark-node", AsVoid(node));
       g_signal_connect(G_OBJECT(menu_item), "activate",
                        G_CALLBACK(OnMenuItemActivated), this);
       g_signal_connect(G_OBJECT(menu_item), "button-press-event",
@@ -144,9 +148,9 @@ gboolean BookmarkMenuController::OnButtonPressed(
     BookmarkMenuController* controller) {
   if (event->button == 3) {
     // Show the right click menu and stop processing this button event.
-    BookmarkNode* node = GetNodeFromMenuItem(sender);
-    BookmarkNode* parent = node->GetParent();
-    std::vector<BookmarkNode*> nodes;
+    const BookmarkNode* node = GetNodeFromMenuItem(sender);
+    const BookmarkNode* parent = node->GetParent();
+    std::vector<const BookmarkNode*> nodes;
     nodes.push_back(node);
     controller->context_menu_.reset(
         new BookmarkContextMenu(
diff --git a/chrome/browser/gtk/bookmark_menu_controller_gtk.h b/chrome/browser/gtk/bookmark_menu_controller_gtk.h
index 4d8e7b5..07993c4 100644
--- a/chrome/browser/gtk/bookmark_menu_controller_gtk.h
+++ b/chrome/browser/gtk/bookmark_menu_controller_gtk.h
@@ -29,7 +29,7 @@ class BookmarkMenuController : public BaseBookmarkModelObserver {
                          Profile* profile,
                          PageNavigator* page_navigator,
                          GtkWindow* window,
-                         BookmarkNode* node,
+                         const BookmarkNode* node,
                          int start_child_index,
                          bool show_other_folder);
   virtual ~BookmarkMenuController();
@@ -40,12 +40,12 @@ class BookmarkMenuController : public BaseBookmarkModelObserver {
   // Overridden from BaseBookmarkModelObserver:
   virtual void BookmarkModelChanged();
   virtual void BookmarkNodeFavIconLoaded(BookmarkModel* model,
-                                         BookmarkNode* node);
+                                         const BookmarkNode* node);
 
  private:
   // Recursively change the bookmark hierarchy rooted in |parent| into a set of
   // gtk menus rooted in |menu|.
-  void BuildMenu(BookmarkNode* parent,
+  void BuildMenu(const BookmarkNode* parent,
                  int start_child_index,
                  GtkWidget* menu);
 
@@ -80,7 +80,7 @@ class BookmarkMenuController : public BaseBookmarkModelObserver {
   BookmarkModel* model_;
 
   // The node we're showing the contents of.
-  BookmarkNode* node_;
+  const BookmarkNode* node_;
 
   // Our bookmark menus. We don't use the MenuGtk class because we have to do
   // all sorts of weird non-standard things with this menu, like:
@@ -90,7 +90,7 @@ class BookmarkMenuController : public BaseBookmarkModelObserver {
 
   // Mapping from node to GtkMenuItem menu id. This only contains entries for
   // nodes of type URL.
-  std::map<BookmarkNode*, GtkWidget*> node_to_menu_widget_map_;
+  std::map<const BookmarkNode*, GtkWidget*> node_to_menu_widget_map_;
 
   // Owns our right click context menu.
   scoped_ptr<BookmarkContextMenu> context_menu_;
diff --git a/chrome/browser/gtk/bookmark_tree_model.cc b/chrome/browser/gtk/bookmark_tree_model.cc
index 14f7471..ab3b24e 100644
--- a/chrome/browser/gtk/bookmark_tree_model.cc
+++ b/chrome/browser/gtk/bookmark_tree_model.cc
@@ -13,7 +13,7 @@
 
 namespace {
 
-void AddSingleNodeToTreeStore(GtkTreeStore* store, BookmarkNode* node,
+void AddSingleNodeToTreeStore(GtkTreeStore* store, const BookmarkNode* node,
                               GtkTreeIter *iter, GtkTreeIter* parent) {
   gtk_tree_store_append(store, iter, parent);
   // TODO(estade): we should show the folder open icon when it's expanded.
@@ -29,10 +29,10 @@ void AddSingleNodeToTreeStore(GtkTreeStore* store, BookmarkNode* node,
 // Helper function for CommitTreeStoreDifferencesBetween() which recursively
 // merges changes back from a GtkTreeStore into a tree of BookmarkNodes. This
 // function only works on non-root nodes; our caller handles that special case.
-void RecursiveResolve(BookmarkModel* bb_model, BookmarkNode* bb_node,
+void RecursiveResolve(BookmarkModel* bb_model, const BookmarkNode* bb_node,
                       GtkTreeModel* tree_model, GtkTreeIter* parent_iter,
                       GtkTreePath* selected_path,
-                      BookmarkNode** selected_node) {
+                      const BookmarkNode** selected_node) {
   GtkTreePath* current_path = gtk_tree_model_get_path(tree_model, parent_iter);
   if (gtk_tree_path_compare(current_path, selected_path) == 0)
     *selected_node = bb_node;
@@ -44,7 +44,7 @@ void RecursiveResolve(BookmarkModel* bb_model, BookmarkNode* bb_node,
       int id = bookmark_utils::GetIdFromTreeIter(tree_model, &child_iter);
       std::wstring title =
           bookmark_utils::GetTitleFromTreeIter(tree_model, &child_iter);
-      BookmarkNode* child_bb_node = NULL;
+      const BookmarkNode* child_bb_node = NULL;
       if (id == 0) {
         child_bb_node = bb_model->AddGroup(bb_node, bb_node->GetChildCount(),
                                            title);
@@ -52,7 +52,7 @@ void RecursiveResolve(BookmarkModel* bb_model, BookmarkNode* bb_node,
         // Existing node, reset the title (BBModel ignores changes if the title
         // is the same).
         for (int j = 0; j < bb_node->GetChildCount(); ++j) {
-          BookmarkNode* node = bb_node->GetChild(j);
+          const BookmarkNode* node = bb_node->GetChild(j);
           if (node->is_folder() && node->id() == id) {
             child_bb_node = node;
             break;
@@ -79,14 +79,14 @@ GtkTreeStore* MakeFolderTreeStore() {
 
 void AddToTreeStore(BookmarkModel* model, int selected_id,
                     GtkTreeStore* store, GtkTreeIter* selected_iter) {
-  BookmarkNode* root_node = model->root_node();
+  const BookmarkNode* root_node = model->root_node();
   for (int i = 0; i < root_node->GetChildCount(); ++i) {
     AddToTreeStoreAt(root_node->GetChild(i), selected_id, store,
                      selected_iter, NULL);
   }
 }
 
-void AddToTreeStoreAt(BookmarkNode* node, int selected_id,
+void AddToTreeStoreAt(const BookmarkNode* node, int selected_id,
                       GtkTreeStore* store, GtkTreeIter* selected_iter,
                       GtkTreeIter* parent) {
   if (!node->is_folder())
@@ -107,9 +107,9 @@ void AddToTreeStoreAt(BookmarkNode* node, int selected_id,
   }
 }
 
-BookmarkNode* CommitTreeStoreDifferencesBetween(
+const BookmarkNode* CommitTreeStoreDifferencesBetween(
     BookmarkModel* bb_model, GtkTreeStore* tree_store, GtkTreeIter* selected) {
-  BookmarkNode* node_to_return = NULL;
+  const BookmarkNode* node_to_return = NULL;
   GtkTreeModel* tree_model = GTK_TREE_MODEL(tree_store);
 
   GtkTreePath* selected_path = gtk_tree_model_get_path(tree_model, selected);
@@ -123,15 +123,15 @@ BookmarkNode* CommitTreeStoreDifferencesBetween(
   // set of top level nodes that are the root BookmarksNode's children. These
   // items in the top level are not editable and therefore don't need the extra
   // complexity of trying to modify their title.
-  BookmarkNode* root_node = bb_model->root_node();
+  const BookmarkNode* root_node = bb_model->root_node();
   do {
     DCHECK(GetIdFromTreeIter(tree_model, &tree_root) != 0)
         << "It should be impossible to add another toplevel node";
 
     int id = GetIdFromTreeIter(tree_model, &tree_root);
-    BookmarkNode* child_node = NULL;
+    const BookmarkNode* child_node = NULL;
     for (int j = 0; j < root_node->GetChildCount(); ++j) {
-      BookmarkNode* node = root_node->GetChild(j);
+      const BookmarkNode* node = root_node->GetChild(j);
       if (node->is_folder() && node->id() == id) {
         child_node = node;
         break;
diff --git a/chrome/browser/gtk/bookmark_tree_model.h b/chrome/browser/gtk/bookmark_tree_model.h
index 4ca0c5b..c691212 100644
--- a/chrome/browser/gtk/bookmark_tree_model.h
+++ b/chrome/browser/gtk/bookmark_tree_model.h
@@ -41,14 +41,14 @@ void AddToTreeStore(BookmarkModel* model, int selected_id,
 
 // As above, but inserts just the tree rooted at |node| as a child of |parent|.
 // If |parent| is NULL, add it at the top level.
-void AddToTreeStoreAt(BookmarkNode* node, int selected_id,
+void AddToTreeStoreAt(const BookmarkNode* node, int selected_id,
                       GtkTreeStore* store, GtkTreeIter* selected_iter,
                       GtkTreeIter* parent);
 
 // Commits changes to a GtkTreeStore built from BuildTreeStoreFrom() back
 // into the BookmarkModel it was generated from.  Returns the BookmarkNode that
 // represented by |selected|.
-BookmarkNode* CommitTreeStoreDifferencesBetween(
+const BookmarkNode* CommitTreeStoreDifferencesBetween(
     BookmarkModel* model, GtkTreeStore* tree_store,
     GtkTreeIter* selected);
 
diff --git a/chrome/browser/gtk/bookmark_utils_gtk.cc b/chrome/browser/gtk/bookmark_utils_gtk.cc
index 313dca4..4551794 100644
--- a/chrome/browser/gtk/bookmark_utils_gtk.cc
+++ b/chrome/browser/gtk/bookmark_utils_gtk.cc
@@ -48,7 +48,7 @@ GdkPixbuf* GetDefaultFavicon() {
   return default_bookmark_icon;
 }
 
-GdkPixbuf* GetPixbufForNode(BookmarkNode* node, BookmarkModel* model) {
+GdkPixbuf* GetPixbufForNode(const BookmarkNode* node, BookmarkModel* model) {
   GdkPixbuf* pixbuf;
 
   if (node->is_url()) {
@@ -68,17 +68,17 @@ GdkPixbuf* GetPixbufForNode(BookmarkNode* node, BookmarkModel* model) {
 
 // DnD-related -----------------------------------------------------------------
 
-void WriteBookmarkToSelection(BookmarkNode* node,
+void WriteBookmarkToSelection(const BookmarkNode* node,
                               GtkSelectionData* selection_data,
                               guint target_type,
                               Profile* profile) {
   DCHECK(node);
-  std::vector<BookmarkNode*> nodes;
+  std::vector<const BookmarkNode*> nodes;
   nodes.push_back(node);
   WriteBookmarksToSelection(nodes, selection_data, target_type, profile);
 }
 
-void WriteBookmarksToSelection(const std::vector<BookmarkNode*>& nodes,
+void WriteBookmarksToSelection(const std::vector<const BookmarkNode*>& nodes,
                                GtkSelectionData* selection_data,
                                guint target_type,
                                Profile* profile) {
@@ -100,7 +100,7 @@ void WriteBookmarksToSelection(const std::vector<BookmarkNode*>& nodes,
   }
 }
 
-std::vector<BookmarkNode*> GetNodesFromSelection(
+std::vector<const BookmarkNode*> GetNodesFromSelection(
     GdkDragContext* context,
     GtkSelectionData* selection_data,
     guint target_type,
@@ -130,7 +130,7 @@ std::vector<BookmarkNode*> GetNodesFromSelection(
     }
   }
 
-  return std::vector<BookmarkNode*>();
+  return std::vector<const BookmarkNode*>();
 }
 
 }  // namespace bookmark_utils
diff --git a/chrome/browser/gtk/bookmark_utils_gtk.h b/chrome/browser/gtk/bookmark_utils_gtk.h
index 819748c..32fe615 100644
--- a/chrome/browser/gtk/bookmark_utils_gtk.h
+++ b/chrome/browser/gtk/bookmark_utils_gtk.h
@@ -25,25 +25,25 @@ GdkPixbuf* GetDefaultFavicon();
 
 // Get the image that is used to represent the node. This function adds a ref
 // to the returned pixbuf, so it requires a matching call to g_object_unref().
-GdkPixbuf* GetPixbufForNode(BookmarkNode* node, BookmarkModel* model);
+GdkPixbuf* GetPixbufForNode(const BookmarkNode* node, BookmarkModel* model);
 
 // Drag and drop. --------------------------------------------------------------
 
 // Pickle a node into a GtkSelection.
-void WriteBookmarkToSelection(BookmarkNode* node,
+void WriteBookmarkToSelection(const BookmarkNode* node,
                               GtkSelectionData* selection_data,
                               guint target_type,
                               Profile* profile);
 
 // Pickle a vector of nodes into a GtkSelection.
-void WriteBookmarksToSelection(const std::vector<BookmarkNode*>& nodes,
+void WriteBookmarksToSelection(const std::vector<const BookmarkNode*>& nodes,
                                GtkSelectionData* selection_data,
                                guint target_type,
                                Profile* profile);
 
 // Un-pickle node(s) from a GtkSelection.
 // The last two arguments are out parameters.
-std::vector<BookmarkNode*> GetNodesFromSelection(
+std::vector<const BookmarkNode*> GetNodesFromSelection(
     GdkDragContext* context,
     GtkSelectionData* selection_data,
     guint target_type,
diff --git a/chrome/browser/importer/importer.cc b/chrome/browser/importer/importer.cc
index 74d2694..5af5572 100644
--- a/chrome/browser/importer/importer.cc
+++ b/chrome/browser/importer/importer.cc
@@ -95,7 +95,7 @@ void ProfileWriter::AddBookmarkEntry(
       GenerateUniqueFolderName(model, first_folder_name);
 
   bool show_bookmark_toolbar = false;
-  std::set<BookmarkNode*> groups_added_to;
+  std::set<const BookmarkNode*> groups_added_to;
   for (std::vector<BookmarkEntry>::const_iterator it = bookmark.begin();
        it != bookmark.end(); ++it) {
     // Don't insert this url if it isn't valid.
@@ -113,16 +113,16 @@ void ProfileWriter::AddBookmarkEntry(
     // the subgroup of path[i-1]. Finally they construct a path in the
     // model:
     //   path[0] \ path[1] \ ... \ path[size() - 1]
-    BookmarkNode* parent =
+    const BookmarkNode* parent =
         (it->in_toolbar ? model->GetBookmarkBarNode() : model->other_node());
     for (std::vector<std::wstring>::const_iterator i = it->path.begin();
          i != it->path.end(); ++i) {
-      BookmarkNode* child = NULL;
-      const std::wstring& folder_name = (!import_to_bookmark_bar && 
+      const BookmarkNode* child = NULL;
+      const std::wstring& folder_name = (!import_to_bookmark_bar &&
           !it->in_toolbar && (i == it->path.begin())) ? real_first_folder : *i;
 
       for (int index = 0; index < parent->GetChildCount(); ++index) {
-        BookmarkNode* node = parent->GetChild(index);
+        const BookmarkNode* node = parent->GetChild(index);
         if ((node->GetType() == history::StarredEntry::BOOKMARK_BAR ||
              node->GetType() == history::StarredEntry::USER_GROUP) &&
             node->GetTitle() == folder_name) {
@@ -147,7 +147,8 @@ void ProfileWriter::AddBookmarkEntry(
   // Reset the date modified time of the groups we added to. We do this to
   // make sure the 'recently added to' combobox in the bubble doesn't get random
   // groups.
-  for (std::set<BookmarkNode*>::const_iterator i = groups_added_to.begin();
+  for (std::set<const BookmarkNode*>::const_iterator i =
+          groups_added_to.begin();
        i != groups_added_to.end(); ++i) {
     model->ResetDateGroupModified(*i);
   }
@@ -299,9 +300,9 @@ std::wstring ProfileWriter::GenerateUniqueFolderName(
     const std::wstring& folder_name) {
   // Build a set containing the folder names of the other folder.
   std::set<std::wstring> other_folder_names;
-  BookmarkNode* other = model->other_node();
+  const BookmarkNode* other = model->other_node();
   for (int i = 0; i < other->GetChildCount(); ++i) {
-    BookmarkNode* node = other->GetChild(i);
+    const BookmarkNode* node = other->GetChild(i);
     if (node->is_folder())
       other_folder_names.insert(node->GetTitle());
   }
@@ -324,19 +325,19 @@ bool ProfileWriter::DoesBookmarkExist(
     const BookmarkEntry& entry,
     const std::wstring& first_folder_name,
     bool import_to_bookmark_bar) {
-  std::vector<BookmarkNode*> nodes_with_same_url;
+  std::vector<const BookmarkNode*> nodes_with_same_url;
   model->GetNodesByURL(entry.url, &nodes_with_same_url);
   if (nodes_with_same_url.empty())
     return false;
 
   for (size_t i = 0; i < nodes_with_same_url.size(); ++i) {
-    BookmarkNode* node = nodes_with_same_url[i];
+    const BookmarkNode* node = nodes_with_same_url[i];
     if (entry.title != node->GetTitle())
       continue;
 
     // Does the path match?
     bool found_match = true;
-    BookmarkNode* parent = node->GetParent();
+    const BookmarkNode* parent = node->GetParent();
     for (std::vector<std::wstring>::const_reverse_iterator path_it =
              entry.path.rbegin();
          (path_it != entry.path.rend()) && found_match; ++path_it) {
diff --git a/chrome/browser/importer/importer.h b/chrome/browser/importer/importer.h
index 93ed19b..41ef11b 100644
--- a/chrome/browser/importer/importer.h
+++ b/chrome/browser/importer/importer.h
@@ -172,22 +172,22 @@ class ImporterHost : public base::RefCounted<ImporterHost>,
   // BookmarkModelObserver methods.
   virtual void Loaded(BookmarkModel* model);
   virtual void BookmarkNodeMoved(BookmarkModel* model,
-                                 BookmarkNode* old_parent,
+                                 const BookmarkNode* old_parent,
                                  int old_index,
-                                 BookmarkNode* new_parent,
+                                 const BookmarkNode* new_parent,
                                  int new_index) {}
   virtual void BookmarkNodeAdded(BookmarkModel* model,
-                                 BookmarkNode* parent,
+                                 const BookmarkNode* parent,
                                  int index) {}
   virtual void BookmarkNodeRemoved(BookmarkModel* model,
-                                   BookmarkNode* parent,
+                                   const BookmarkNode* parent,
                                    int index) {}
   virtual void BookmarkNodeChanged(BookmarkModel* model,
-                                   BookmarkNode* node) {}
+                                   const BookmarkNode* node) {}
   virtual void BookmarkNodeChildrenReordered(BookmarkModel* model,
-                                             BookmarkNode* node) {}
+                                             const BookmarkNode* node) {}
   virtual void BookmarkNodeFavIconLoaded(BookmarkModel* model,
-                                         BookmarkNode* node) {}
+                                         const BookmarkNode* node) {}
 
   // NotificationObserver method. Called when TemplateURLModel has been loaded.
   void Observe(NotificationType type,
diff --git a/chrome/browser/metrics/metrics_service.cc b/chrome/browser/metrics/metrics_service.cc
index 57a326b..30e1628 100644
--- a/chrome/browser/metrics/metrics_service.cc
+++ b/chrome/browser/metrics/metrics_service.cc
@@ -1699,7 +1699,9 @@ void MetricsService::LogChildProcessChange(
 }
 
 // Recursively counts the number of bookmarks and folders in node.
-static void CountBookmarks(BookmarkNode* node, int* bookmarks, int* folders) {
+static void CountBookmarks(const BookmarkNode* node,
+                           int* bookmarks,
+                           int* folders) {
   if (node->GetType() == history::StarredEntry::URL)
     (*bookmarks)++;
   else
@@ -1708,7 +1710,7 @@ static void CountBookmarks(BookmarkNode* node, int* bookmarks, int* folders) {
     CountBookmarks(node->GetChild(i), bookmarks, folders);
 }
 
-void MetricsService::LogBookmarks(BookmarkNode* node,
+void MetricsService::LogBookmarks(const BookmarkNode* node,
                                   const wchar_t* num_bookmarks_key,
                                   const wchar_t* num_folders_key) {
   DCHECK(node);
diff --git a/chrome/browser/metrics/metrics_service.h b/chrome/browser/metrics/metrics_service.h
index e78a66a..a955da1 100644
--- a/chrome/browser/metrics/metrics_service.h
+++ b/chrome/browser/metrics/metrics_service.h
@@ -316,7 +316,7 @@ class MetricsService : public NotificationObserver,
   // Set the value in preferences for for the number of bookmarks and folders
   // in node. The pref key for the number of bookmarks in num_bookmarks_key and
   // the pref key for number of folders in num_folders_key.
-  void LogBookmarks(BookmarkNode* node,
+  void LogBookmarks(const BookmarkNode* node,
                     const wchar_t* num_bookmarks_key,
                     const wchar_t* num_folders_key);
 
diff --git a/chrome/browser/views/bookmark_bar_view.cc b/chrome/browser/views/bookmark_bar_view.cc
index 0483ca6..459e4c2 100644
--- a/chrome/browser/views/bookmark_bar_view.cc
+++ b/chrome/browser/views/bookmark_bar_view.cc
@@ -740,7 +740,7 @@ int BookmarkBarView::OnDragUpdated(const DropTargetEvent& event) {
   }
 
   if (drop_on || is_over_overflow || is_over_other) {
-    BookmarkNode* node;
+    const BookmarkNode* node;
     if (is_over_other)
       node = model_->other_node();
     else if (is_over_overflow)
@@ -777,8 +777,9 @@ int BookmarkBarView::OnPerformDrop(const DropTargetEvent& event) {
   if (!drop_info_.get() || !drop_info_->drag_operation)
     return DragDropTypes::DRAG_NONE;
 
-  BookmarkNode* root = drop_info_->is_over_other ? model_->other_node() :
-                                                   model_->GetBookmarkBarNode();
+  const 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;
@@ -791,7 +792,7 @@ int BookmarkBarView::OnPerformDrop(const DropTargetEvent& event) {
   }
   drop_info_.reset();
 
-  BookmarkNode* parent_node;
+  const BookmarkNode* parent_node;
   if (is_over_other) {
     parent_node = root;
     index = parent_node->GetChildCount();
@@ -928,7 +929,7 @@ int BookmarkBarView::GetBookmarkButtonCount() {
 }
 
 void BookmarkBarView::Loaded(BookmarkModel* model) {
-  BookmarkNode* node = model_->GetBookmarkBarNode();
+  const 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)
@@ -960,9 +961,9 @@ void BookmarkBarView::BookmarkModelBeingDeleted(BookmarkModel* model) {
 }
 
 void BookmarkBarView::BookmarkNodeMoved(BookmarkModel* model,
-                                        BookmarkNode* old_parent,
+                                        const BookmarkNode* old_parent,
                                         int old_index,
-                                        BookmarkNode* new_parent,
+                                        const BookmarkNode* new_parent,
                                         int new_index) {
   StopThrobbing(true);
   BookmarkNodeRemovedImpl(model, old_parent, old_index);
@@ -971,7 +972,7 @@ void BookmarkBarView::BookmarkNodeMoved(BookmarkModel* model,
 }
 
 void BookmarkBarView::BookmarkNodeAdded(BookmarkModel* model,
-                                        BookmarkNode* parent,
+                                        const BookmarkNode* parent,
                                         int index) {
   StopThrobbing(true);
   BookmarkNodeAddedImpl(model, parent, index);
@@ -979,7 +980,7 @@ void BookmarkBarView::BookmarkNodeAdded(BookmarkModel* model,
 }
 
 void BookmarkBarView::BookmarkNodeAddedImpl(BookmarkModel* model,
-                                            BookmarkNode* parent,
+                                            const BookmarkNode* parent,
                                             int index) {
   NotifyModelChanged();
   if (parent != model_->GetBookmarkBarNode()) {
@@ -993,7 +994,7 @@ void BookmarkBarView::BookmarkNodeAddedImpl(BookmarkModel* model,
 }
 
 void BookmarkBarView::BookmarkNodeRemoved(BookmarkModel* model,
-                                          BookmarkNode* parent,
+                                          const BookmarkNode* parent,
                                           int index) {
   StopThrobbing(true);
   BookmarkNodeRemovedImpl(model, parent, index);
@@ -1001,7 +1002,7 @@ void BookmarkBarView::BookmarkNodeRemoved(BookmarkModel* model,
 }
 
 void BookmarkBarView::BookmarkNodeRemovedImpl(BookmarkModel* model,
-                                              BookmarkNode* parent,
+                                              const BookmarkNode* parent,
                                               int index) {
   StopThrobbing(true);
   // No need to start throbbing again as the bookmark bubble can't be up at
@@ -1021,13 +1022,13 @@ void BookmarkBarView::BookmarkNodeRemovedImpl(BookmarkModel* model,
 }
 
 void BookmarkBarView::BookmarkNodeChanged(BookmarkModel* model,
-                                          BookmarkNode* node) {
+                                          const BookmarkNode* node) {
   NotifyModelChanged();
   BookmarkNodeChangedImpl(model, node);
 }
 
 void BookmarkBarView::BookmarkNodeChangedImpl(BookmarkModel* model,
-                                              BookmarkNode* node) {
+                                              const BookmarkNode* node) {
   if (node->GetParent() != model_->GetBookmarkBarNode()) {
     // We only care about nodes on the bookmark bar.
     return;
@@ -1047,7 +1048,7 @@ void BookmarkBarView::BookmarkNodeChangedImpl(BookmarkModel* model,
 }
 
 void BookmarkBarView::BookmarkNodeChildrenReordered(BookmarkModel* model,
-                                                    BookmarkNode* node) {
+                                                    const BookmarkNode* node) {
   NotifyModelChanged();
   if (node != model_->GetBookmarkBarNode())
     return;  // We only care about reordering of the bookmark bar node.
@@ -1068,7 +1069,7 @@ void BookmarkBarView::BookmarkNodeChildrenReordered(BookmarkModel* model,
 }
 
 void BookmarkBarView::BookmarkNodeFavIconLoaded(BookmarkModel* model,
-                                                BookmarkNode* node) {
+                                                const BookmarkNode* node) {
   BookmarkNodeChangedImpl(model, node);
 }
 
@@ -1093,7 +1094,7 @@ void BookmarkBarView::WriteDragData(View* sender,
   NOTREACHED();
 }
 
-void BookmarkBarView::WriteDragData(BookmarkNode* node,
+void BookmarkBarView::WriteDragData(const BookmarkNode* node,
                                     OSExchangeData* data) {
   DCHECK(node && data);
   BookmarkDragData drag_data(node);
@@ -1123,7 +1124,7 @@ int BookmarkBarView::GetDragOperations(View* sender, int x, int y) {
 void BookmarkBarView::RunMenu(views::View* view,
                               const gfx::Point& pt,
                               gfx::NativeView hwnd) {
-  BookmarkNode* node;
+  const BookmarkNode* node;
   MenuItemView::AnchorPosition anchor_point = MenuItemView::TOPLEFT;
 
   // When we set the menu's position, we must take into account the mirrored
@@ -1176,7 +1177,7 @@ void BookmarkBarView::RunMenu(views::View* view,
 }
 
 void BookmarkBarView::ButtonPressed(views::Button* sender) {
-  BookmarkNode* node;
+  const BookmarkNode* node;
   if (sender->tag() == kOtherFolderButtonTag) {
     node = model_->other_node();
   } else {
@@ -1214,8 +1215,8 @@ void BookmarkBarView::ShowContextMenu(View* source,
     return;
   }
 
-  BookmarkNode* parent = NULL;
-  std::vector<BookmarkNode*> nodes;
+  const BookmarkNode* parent = NULL;
+  std::vector<const BookmarkNode*> nodes;
   if (source == other_bookmarked_button_) {
     parent = model_->other_node();
     // Do this so the user can open all bookmarks. BookmarkContextMenu makes
@@ -1227,7 +1228,7 @@ void BookmarkBarView::ShowContextMenu(View* source,
     int bookmark_button_index = GetChildIndex(source);
     DCHECK(bookmark_button_index != -1 &&
            bookmark_button_index < GetBookmarkButtonCount());
-    BookmarkNode* node =
+    const BookmarkNode* node =
         model_->GetBookmarkBarNode()->GetChild(bookmark_button_index);
     nodes.push_back(node);
     parent = node->GetParent();
@@ -1242,7 +1243,7 @@ void BookmarkBarView::ShowContextMenu(View* source,
   controller.RunMenuAt(x, y);
 }
 
-views::View* BookmarkBarView::CreateBookmarkButton(BookmarkNode* node) {
+views::View* BookmarkBarView::CreateBookmarkButton(const BookmarkNode* node) {
   if (node->is_url()) {
     BookmarkButton* button = new BookmarkButton(this,
                                                 node->GetURL(),
@@ -1259,7 +1260,7 @@ views::View* BookmarkBarView::CreateBookmarkButton(BookmarkNode* node) {
   }
 }
 
-void BookmarkBarView::ConfigureButton(BookmarkNode* node,
+void BookmarkBarView::ConfigureButton(const BookmarkNode* node,
                                       views::TextButton* button) {
   button->SetText(node->GetTitle());
 
@@ -1325,7 +1326,7 @@ void BookmarkBarView::NotifyModelChanged() {
     model_changed_listener_->ModelChanged();
 }
 
-void BookmarkBarView::ShowDropFolderForNode(BookmarkNode* node) {
+void BookmarkBarView::ShowDropFolderForNode(const BookmarkNode* node) {
   if (bookmark_drop_menu_) {
     if (bookmark_drop_menu_->node() == node) {
       // Already showing for the specified node.
@@ -1388,7 +1389,7 @@ void BookmarkBarView::StopShowFolderDropMenuTimer() {
     show_folder_drop_menu_task_->Cancel();
 }
 
-void BookmarkBarView::StartShowFolderDropMenuTimer(BookmarkNode* node) {
+void BookmarkBarView::StartShowFolderDropMenuTimer(const BookmarkNode* node) {
   if (testing_) {
     // So that tests can run as fast as possible disable the delay during
     // testing.
@@ -1462,7 +1463,7 @@ int BookmarkBarView::CalculateDropOperation(const DropTargetEvent& event,
     int button_w = button->width();
     if (button_x < button_w) {
       found = true;
-      BookmarkNode* node = model_->GetBookmarkBarNode()->GetChild(i);
+      const BookmarkNode* node = model_->GetBookmarkBarNode()->GetChild(i);
       if (node->is_folder()) {
         if (button_x <= views::kDropBetweenPixels) {
           *index = i;
@@ -1507,7 +1508,7 @@ int BookmarkBarView::CalculateDropOperation(const DropTargetEvent& event,
   }
 
   if (*drop_on) {
-    BookmarkNode* parent =
+    const BookmarkNode* parent =
         *is_over_other ? model_->other_node() :
                          model_->GetBookmarkBarNode()->GetChild(*index);
     int operation =
@@ -1544,15 +1545,16 @@ void BookmarkBarView::StartThrobbing() {
   if (!GetWidget())
     return;  // We're not showing, don't do anything.
 
-  BookmarkNode* node = model_->GetMostRecentlyAddedNodeForURL(bubble_url_);
+  const BookmarkNode* node =
+      model_->GetMostRecentlyAddedNodeForURL(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())) {
-    BookmarkNode* bbn = model_->GetBookmarkBarNode();
-    BookmarkNode* parent_on_bb = node;
+    const BookmarkNode* bbn = model_->GetBookmarkBarNode();
+    const 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);
diff --git a/chrome/browser/views/bookmark_bar_view.h b/chrome/browser/views/bookmark_bar_view.h
index c747610..e53a2db 100644
--- a/chrome/browser/views/bookmark_bar_view.h
+++ b/chrome/browser/views/bookmark_bar_view.h
@@ -184,7 +184,7 @@ class BookmarkBarView : public views::View,
   // deletes itself once run.
   class ShowFolderDropMenuTask : public Task {
    public:
-    ShowFolderDropMenuTask(BookmarkBarView* view, BookmarkNode* node)
+    ShowFolderDropMenuTask(BookmarkBarView* view, const BookmarkNode* node)
       : view_(view),
         node_(node) {
     }
@@ -204,7 +204,7 @@ class BookmarkBarView : public views::View,
 
    private:
     BookmarkBarView* view_;
-    BookmarkNode* node_;
+    const BookmarkNode* node_;
 
     DISALLOW_COPY_AND_ASSIGN(ShowFolderDropMenuTask);
   };
@@ -233,51 +233,51 @@ class BookmarkBarView : public views::View,
 
   // Invokes added followed by removed.
   virtual void BookmarkNodeMoved(BookmarkModel* model,
-                                 BookmarkNode* old_parent,
+                                 const BookmarkNode* old_parent,
                                  int old_index,
-                                 BookmarkNode* new_parent,
+                                 const BookmarkNode* new_parent,
                                  int new_index);
 
   // Notifies ModelChangeListener of change.
   // If the node was added to the root node, a button is created and added to
   // this bookmark bar view.
   virtual void BookmarkNodeAdded(BookmarkModel* model,
-                                 BookmarkNode* parent,
+                                 const BookmarkNode* parent,
                                  int index);
 
   // Implementation for BookmarkNodeAddedImpl.
   void BookmarkNodeAddedImpl(BookmarkModel* model,
-                             BookmarkNode* parent,
+                             const BookmarkNode* parent,
                              int index);
 
   // Notifies ModelChangeListener of change.
   // If the node was a child of the root node, the button corresponding to it
   // is removed.
   virtual void BookmarkNodeRemoved(BookmarkModel* model,
-                                   BookmarkNode* parent,
+                                   const BookmarkNode* parent,
                                    int index);
 
   // Implementation for BookmarkNodeRemoved.
   void BookmarkNodeRemovedImpl(BookmarkModel* model,
-                               BookmarkNode* parent,
+                               const BookmarkNode* parent,
                                int index);
 
   // Notifies ModelChangedListener and invokes BookmarkNodeChangedImpl.
   virtual void BookmarkNodeChanged(BookmarkModel* model,
-                                   BookmarkNode* node);
+                                   const BookmarkNode* node);
 
   // If the node is a child of the root node, the button is updated
   // appropriately.
-  void BookmarkNodeChangedImpl(BookmarkModel* model, BookmarkNode* node);
+  void BookmarkNodeChangedImpl(BookmarkModel* model, const BookmarkNode* node);
 
   virtual void BookmarkNodeChildrenReordered(BookmarkModel* model,
-                                             BookmarkNode* node);
+                                             const BookmarkNode* node);
 
   // Invoked when the favicon is available. If the node is a child of the
   // root node, the appropriate button is updated. If a menu is showing, the
   // call is forwarded to the menu to allow for it to update the icon.
   virtual void BookmarkNodeFavIconLoaded(BookmarkModel* model,
-                                         BookmarkNode* node);
+                                         const BookmarkNode* node);
 
   // DragController method. Determines the node representing sender and invokes
   // WriteDragData to write the actual data.
@@ -287,7 +287,7 @@ class BookmarkBarView : public views::View,
                              OSExchangeData* data);
 
   // Writes a BookmarkDragData for node to data.
-  void WriteDragData(BookmarkNode* node, OSExchangeData* data);
+  void WriteDragData(const BookmarkNode* node, OSExchangeData* data);
 
   // Returns the drag operations for the specified button.
   virtual int GetDragOperations(views::View* sender, int x, int y);
@@ -313,11 +313,11 @@ class BookmarkBarView : public views::View,
                                bool is_mouse_gesture);
 
   // Creates the button for rendering the specified bookmark node.
-  views::View* CreateBookmarkButton(BookmarkNode* node);
+  views::View* CreateBookmarkButton(const BookmarkNode* node);
 
   // COnfigures the button from the specified node. This sets the text,
   // and icon.
-  void ConfigureButton(BookmarkNode* node, views::TextButton* button);
+  void ConfigureButton(const BookmarkNode* node, views::TextButton* button);
 
   // Used when showing the menu allowing the user to choose when the bar is
   // visible. Return value corresponds to the users preference for when the
@@ -337,13 +337,13 @@ class BookmarkBarView : public views::View,
   void NotifyModelChanged();
 
   // Shows the menu used during drag and drop for the specified node.
-  void ShowDropFolderForNode(BookmarkNode* node);
+  void ShowDropFolderForNode(const BookmarkNode* node);
 
   // Cancels the timer used to show a drop menu.
   void StopShowFolderDropMenuTimer();
 
   // Stars the timer used to show a drop menu for node.
-  void StartShowFolderDropMenuTimer(BookmarkNode* node);
+  void StartShowFolderDropMenuTimer(const BookmarkNode* node);
 
   // Returns the drop operation and index for the drop based on the event
   // and data. Returns DragDropTypes::DRAG_NONE if not a valid location.
diff --git a/chrome/browser/views/bookmark_bar_view_test.cc b/chrome/browser/views/bookmark_bar_view_test.cc
index 73eb686..8313920 100644
--- a/chrome/browser/views/bookmark_bar_view_test.cc
+++ b/chrome/browser/views/bookmark_bar_view_test.cc
@@ -137,9 +137,10 @@ class BookmarkBarViewEventTestBase : public ViewEventTestBase {
   void AddTestData(bool big_menu) {
     std::string test_base = "file:///c:/tmp/";
 
-    BookmarkNode* f1 = model_->AddGroup(model_->GetBookmarkBarNode(), 0, L"F1");
+    const BookmarkNode* f1 = model_->AddGroup(
+        model_->GetBookmarkBarNode(), 0, L"F1");
     model_->AddURL(f1, 0, L"f1a", GURL(test_base + "f1a"));
-    BookmarkNode* f11 = model_->AddGroup(f1, 1, L"F11");
+    const BookmarkNode* f11 = model_->AddGroup(f1, 1, L"F11");
     model_->AddURL(f11, 0, L"f11a", GURL(test_base + "f11a"));
     if (big_menu) {
       for (int i = 1; i <= 100; ++i) {
@@ -156,10 +157,10 @@ class BookmarkBarViewEventTestBase : public ViewEventTestBase {
     model_->AddURL(model_->GetBookmarkBarNode(), 4, L"d",
                    GURL(test_base + "d"));
     model_->AddURL(model_->other_node(), 0, L"oa", GURL(test_base + "oa"));
-    BookmarkNode* of = model_->AddGroup(model_->other_node(), 1, L"OF");
+    const BookmarkNode* of = model_->AddGroup(model_->other_node(), 1, L"OF");
     model_->AddURL(of, 0, L"ofa", GURL(test_base + "ofa"));
     model_->AddURL(of, 1, L"ofb", GURL(test_base + "ofb"));
-    BookmarkNode* of2 = model_->AddGroup(model_->other_node(), 2, L"OF2");
+    const BookmarkNode* of2 = model_->AddGroup(model_->other_node(), 2, L"OF2");
     model_->AddURL(of2, 0, L"of2a", GURL(test_base + "of2a"));
     model_->AddURL(of2, 1, L"of2b", GURL(test_base + "of2b"));
   }
diff --git a/chrome/browser/views/bookmark_bubble_view.cc b/chrome/browser/views/bookmark_bubble_view.cc
index 9a2a8f6..69af750 100644
--- a/chrome/browser/views/bookmark_bubble_view.cc
+++ b/chrome/browser/views/bookmark_bubble_view.cc
@@ -74,7 +74,7 @@ bool IsBookmarkBubbleViewShowing() {
 // RecentlyUsedFoldersModel ---------------------------------------------------
 
 BookmarkBubbleView::RecentlyUsedFoldersModel::RecentlyUsedFoldersModel(
-    BookmarkModel* bb_model, BookmarkNode* node)
+    BookmarkModel* bb_model, const BookmarkNode* node)
       // Use + 2 to account for bookmark bar and other node.
       : nodes_(bookmark_utils::GetMostRecentlyModifiedGroups(
             bb_model, kMaxMRUFolders + 2)),
@@ -117,14 +117,14 @@ std::wstring BookmarkBubbleView::RecentlyUsedFoldersModel::GetItemAt(
   return nodes_[index]->GetTitle();
 }
 
-BookmarkNode* BookmarkBubbleView::RecentlyUsedFoldersModel::GetNodeAt(
+const BookmarkNode* BookmarkBubbleView::RecentlyUsedFoldersModel::GetNodeAt(
     int index) {
   return nodes_[index];
 }
 
 void BookmarkBubbleView::RecentlyUsedFoldersModel::RemoveNode(
-    BookmarkNode* node) {
-  std::vector<BookmarkNode*>::iterator i =
+    const BookmarkNode* node) {
+  std::vector<const BookmarkNode*>::iterator i =
       find(nodes_.begin(), nodes_.end(), node);
   if (i != nodes_.end())
     nodes_.erase(i);
@@ -169,7 +169,7 @@ BookmarkBubbleView::~BookmarkBubbleView() {
     ApplyEdits();
   } else if (remove_bookmark_) {
     BookmarkModel* model = profile_->GetBookmarkModel();
-    BookmarkNode* node = model->GetMostRecentlyAddedNodeForURL(url_);
+    const BookmarkNode* node = model->GetMostRecentlyAddedNodeForURL(url_);
     if (node)
       model->Remove(node->GetParent(), node->GetParent()->IndexOfChild(node));
   }
@@ -304,7 +304,8 @@ void BookmarkBubbleView::Init() {
 
 std::wstring BookmarkBubbleView::GetTitle() {
   BookmarkModel* bookmark_model= profile_->GetBookmarkModel();
-  BookmarkNode* node = bookmark_model->GetMostRecentlyAddedNodeForURL(url_);
+  const BookmarkNode* node =
+      bookmark_model->GetMostRecentlyAddedNodeForURL(url_);
   if (node)
     return node->GetTitle();
   else
@@ -374,7 +375,7 @@ void BookmarkBubbleView::Close() {
 }
 
 void BookmarkBubbleView::ShowEditor() {
-  BookmarkNode* node =
+  const BookmarkNode* node =
       profile_->GetBookmarkModel()->GetMostRecentlyAddedNodeForURL(url_);
 
   // Commit any edits now.
@@ -408,7 +409,7 @@ void BookmarkBubbleView::ApplyEdits() {
   apply_edits_ = false;
 
   BookmarkModel* model = profile_->GetBookmarkModel();
-  BookmarkNode* node = model->GetMostRecentlyAddedNodeForURL(url_);
+  const BookmarkNode* node = model->GetMostRecentlyAddedNodeForURL(url_);
   if (node) {
     const std::wstring new_title = title_tf_->text();
     if (new_title != node->GetTitle()) {
@@ -419,7 +420,7 @@ void BookmarkBubbleView::ApplyEdits() {
     // Last index means 'Choose another folder...'
     if (parent_combobox_->selected_item() <
         parent_model_.GetItemCount(parent_combobox_) - 1) {
-      BookmarkNode* new_parent =
+      const BookmarkNode* new_parent =
           parent_model_.GetNodeAt(parent_combobox_->selected_item());
       if (new_parent != node->GetParent()) {
         UserMetrics::RecordAction(L"BookmarkBubble_ChangeParent", profile_);
diff --git a/chrome/browser/views/bookmark_bubble_view.h b/chrome/browser/views/bookmark_bubble_view.h
index 5083a52..517aea9 100644
--- a/chrome/browser/views/bookmark_bubble_view.h
+++ b/chrome/browser/views/bookmark_bubble_view.h
@@ -62,23 +62,23 @@ class BookmarkBubbleView : public views::View,
   // also contains an extra item that shows the text 'Choose another folder...'.
   class RecentlyUsedFoldersModel : public views::Combobox::Model {
    public:
-    RecentlyUsedFoldersModel(BookmarkModel* bb_model, BookmarkNode* node);
+    RecentlyUsedFoldersModel(BookmarkModel* bb_model, const BookmarkNode* node);
 
     // Combobox::Model methods. Call through to nodes_.
     virtual int GetItemCount(views::Combobox* source);
     virtual std::wstring GetItemAt(views::Combobox* source, int index);
 
     // Returns the node at the specified index.
-    BookmarkNode* GetNodeAt(int index);
+    const BookmarkNode* GetNodeAt(int index);
 
     // Returns the index of the original parent folder.
     int node_parent_index() const { return node_parent_index_; }
 
    private:
     // Removes node from nodes_. Does nothing if node is not in nodes_.
-    void RemoveNode(BookmarkNode* node);
+    void RemoveNode(const BookmarkNode* node);
 
-    std::vector<BookmarkNode*> nodes_;
+    std::vector<const BookmarkNode*> nodes_;
     int node_parent_index_;
 
     DISALLOW_COPY_AND_ASSIGN(RecentlyUsedFoldersModel);
diff --git a/chrome/browser/views/bookmark_context_menu.cc b/chrome/browser/views/bookmark_context_menu.cc
index a29336b..9d9ca29 100644
--- a/chrome/browser/views/bookmark_context_menu.cc
+++ b/chrome/browser/views/bookmark_context_menu.cc
@@ -30,7 +30,7 @@ namespace {
 
 // Returns true if the specified node is of type URL, or has a descendant
 // of type URL.
-bool NodeHasURLs(BookmarkNode* node) {
+bool NodeHasURLs(const BookmarkNode* node) {
   if (node->is_url())
     return true;
 
@@ -57,7 +57,7 @@ class EditFolderController : public InputWindowDialog::Delegate,
 
   static void Show(Profile* profile,
                    gfx::NativeView wnd,
-                   BookmarkNode* node,
+                   const BookmarkNode* node,
                    bool is_new,
                    bool show_in_manager) {
     // EditFolderController deletes itself when done.
@@ -69,7 +69,7 @@ class EditFolderController : public InputWindowDialog::Delegate,
  private:
   EditFolderController(Profile* profile,
                        gfx::NativeView wnd,
-                       BookmarkNode* node,
+                       const BookmarkNode* node,
                        bool is_new,
                        bool show_in_manager)
       : profile_(profile),
@@ -103,7 +103,7 @@ class EditFolderController : public InputWindowDialog::Delegate,
 
   virtual void InputAccepted(const std::wstring& text) {
     if (is_new_) {
-      ALLOW_UNUSED BookmarkNode* node =
+      ALLOW_UNUSED const BookmarkNode* node =
           model_->AddGroup(node_, node_->GetChildCount(), text);
       if (show_in_manager_) {
 #if defined(OS_WIN) || (defined(OS_LINUX) && !defined(TOOLKIT_VIEWS))
@@ -130,35 +130,36 @@ class EditFolderController : public InputWindowDialog::Delegate,
   }
 
   virtual void BookmarkNodeMoved(BookmarkModel* model,
-                                 BookmarkNode* old_parent,
+                                 const BookmarkNode* old_parent,
                                  int old_index,
-                                 BookmarkNode* new_parent,
+                                 const BookmarkNode* new_parent,
                                  int new_index) {
     ModelChanged();
   }
 
   virtual void BookmarkNodeAdded(BookmarkModel* model,
-                                 BookmarkNode* parent,
+                                 const BookmarkNode* parent,
                                  int index) {
     ModelChanged();
   }
 
   virtual void BookmarkNodeRemoved(BookmarkModel* model,
-                                   BookmarkNode* parent,
+                                   const BookmarkNode* parent,
                                    int index,
-                                   BookmarkNode* node) {
+                                   const BookmarkNode* node) {
     ModelChanged();
   }
 
-  virtual void BookmarkNodeChanged(BookmarkModel* model, BookmarkNode* node) {
+  virtual void BookmarkNodeChanged(BookmarkModel* model,
+                                   const BookmarkNode* node) {
     ModelChanged();
   }
 
   virtual void BookmarkNodeFavIconLoaded(BookmarkModel* model,
-                                         BookmarkNode* node) {}
+                                         const BookmarkNode* node) {}
 
   virtual void BookmarkNodeChildrenReordered(BookmarkModel* model,
-                                             BookmarkNode* node) {
+                                             const BookmarkNode* node) {
     ModelChanged();
   }
 
@@ -170,7 +171,7 @@ class EditFolderController : public InputWindowDialog::Delegate,
   BookmarkModel* model_;
   // If is_new is true, this is the parent to create the new node under.
   // Otherwise this is the node to change the title of.
-  BookmarkNode* node_;
+  const BookmarkNode* node_;
 
   bool is_new_;
 
@@ -192,7 +193,7 @@ class SelectOnCreationHandler : public BookmarkEditor::Handler {
   explicit SelectOnCreationHandler(Profile* profile) : profile_(profile) {
   }
 
-  virtual void NodeCreated(BookmarkNode* new_node) {
+  virtual void NodeCreated(const BookmarkNode* new_node) {
     BookmarkManager::SelectInTree(profile_, new_node);
   }
 
@@ -212,8 +213,8 @@ BookmarkContextMenu::BookmarkContextMenu(
     Profile* profile,
     Browser* browser,
     PageNavigator* navigator,
-    BookmarkNode* parent,
-    const std::vector<BookmarkNode*>& selection,
+    const BookmarkNode* parent,
+    const std::vector<const BookmarkNode*>& selection,
     ConfigurationType configuration)
     : wnd_(wnd),
       profile_(profile),
@@ -502,33 +503,33 @@ void BookmarkContextMenu::BookmarkModelBeingDeleted(BookmarkModel* model) {
 }
 
 void BookmarkContextMenu::BookmarkNodeMoved(BookmarkModel* model,
-                                            BookmarkNode* old_parent,
+                                            const BookmarkNode* old_parent,
                                             int old_index,
-                                            BookmarkNode* new_parent,
+                                            const BookmarkNode* new_parent,
                                             int new_index) {
   ModelChanged();
 }
 
 void BookmarkContextMenu::BookmarkNodeAdded(BookmarkModel* model,
-                                            BookmarkNode* parent,
+                                            const BookmarkNode* parent,
                                             int index) {
   ModelChanged();
 }
 
 void BookmarkContextMenu::BookmarkNodeRemoved(BookmarkModel* model,
-                                              BookmarkNode* parent,
+                                              const BookmarkNode* parent,
                                               int index,
-                                              BookmarkNode* node) {
+                                              const BookmarkNode* node) {
   ModelChanged();
 }
 
 void BookmarkContextMenu::BookmarkNodeChanged(BookmarkModel* model,
-                                              BookmarkNode* node) {
+                                              const BookmarkNode* node) {
   ModelChanged();
 }
 
-void BookmarkContextMenu::BookmarkNodeChildrenReordered(BookmarkModel* model,
-                                                        BookmarkNode* node) {
+void BookmarkContextMenu::BookmarkNodeChildrenReordered(
+    BookmarkModel* model, const BookmarkNode* node) {
   ModelChanged();
 }
 
@@ -551,7 +552,7 @@ bool BookmarkContextMenu::HasURLs() const {
   return false;
 }
 
-BookmarkNode* BookmarkContextMenu::GetParentForNewNodes() const {
+const BookmarkNode* BookmarkContextMenu::GetParentForNewNodes() const {
   return (selection_.size() == 1 && selection_[0]->is_folder()) ?
       selection_[0] : parent_;
 }
diff --git a/chrome/browser/views/bookmark_context_menu.h b/chrome/browser/views/bookmark_context_menu.h
index 9903f44..f9e6584 100644
--- a/chrome/browser/views/bookmark_context_menu.h
+++ b/chrome/browser/views/bookmark_context_menu.h
@@ -59,8 +59,8 @@ class BookmarkContextMenu : public BookmarkModelObserver,
                       Profile* profile,
                       Browser* browser,
                       PageNavigator* navigator,
-                      BookmarkNode* parent,
-                      const std::vector<BookmarkNode*>& selection,
+                      const BookmarkNode* parent,
+                      const std::vector<const BookmarkNode*>& selection,
                       ConfigurationType configuration);
   virtual ~BookmarkContextMenu();
 
@@ -89,23 +89,23 @@ class BookmarkContextMenu : public BookmarkModelObserver,
   virtual void Loaded(BookmarkModel* model) {}
   virtual void BookmarkModelBeingDeleted(BookmarkModel* model);
   virtual void BookmarkNodeMoved(BookmarkModel* model,
-                                 BookmarkNode* old_parent,
+                                 const BookmarkNode* old_parent,
                                  int old_index,
-                                 BookmarkNode* new_parent,
+                                 const BookmarkNode* new_parent,
                                  int new_index);
   virtual void BookmarkNodeAdded(BookmarkModel* model,
-                                 BookmarkNode* parent,
+                                 const BookmarkNode* parent,
                                  int index);
   virtual void BookmarkNodeRemoved(BookmarkModel* model,
-                                   BookmarkNode* parent,
+                                   const BookmarkNode* parent,
                                    int index,
-                                   BookmarkNode* node);
+                                   const BookmarkNode* node);
   virtual void BookmarkNodeChanged(BookmarkModel* model,
-                                   BookmarkNode* node);
+                                   const BookmarkNode* node);
   virtual void BookmarkNodeFavIconLoaded(BookmarkModel* model,
-                                         BookmarkNode* node) {}
+                                         const BookmarkNode* node) {}
   virtual void BookmarkNodeChildrenReordered(BookmarkModel* model,
-                                             BookmarkNode* node);
+                                             const BookmarkNode* node);
 
   // Invoked from the various bookmark model observer methods. Closes the menu.
   void ModelChanged();
@@ -131,14 +131,14 @@ class BookmarkContextMenu : public BookmarkModelObserver,
   // Returns the parent for newly created folders/bookmarks. If selection_
   // has one element and it is a folder, selection_[0] is returned, otherwise
   // parent_ is returned.
-  BookmarkNode* GetParentForNewNodes() const;
+  const BookmarkNode* GetParentForNewNodes() const;
 
   gfx::NativeView wnd_;
   Profile* profile_;
   Browser* browser_;
   PageNavigator* navigator_;
-  BookmarkNode* parent_;
-  std::vector<BookmarkNode*> selection_;
+  const BookmarkNode* parent_;
+  std::vector<const BookmarkNode*> selection_;
   BookmarkModel* model_;
   ConfigurationType configuration_;
 
diff --git a/chrome/browser/views/bookmark_context_menu_test.cc b/chrome/browser/views/bookmark_context_menu_test.cc
index 44b9609..217764c 100644
--- a/chrome/browser/views/bookmark_context_menu_test.cc
+++ b/chrome/browser/views/bookmark_context_menu_test.cc
@@ -86,14 +86,14 @@ class BookmarkContextMenuTest : public testing::Test {
 
     model_->AddURL(model_->GetBookmarkBarNode(), 0, L"a",
                    GURL(test_base + "a"));
-    BookmarkNode* f1 =
+    const BookmarkNode* f1 =
         model_->AddGroup(model_->GetBookmarkBarNode(), 1, L"F1");
     model_->AddURL(f1, 0, L"f1a", GURL(test_base + "f1a"));
-    BookmarkNode* f11 = model_->AddGroup(f1, 1, L"F11");
+    const BookmarkNode* f11 = model_->AddGroup(f1, 1, L"F11");
     model_->AddURL(f11, 0, L"f11a", GURL(test_base + "f11a"));
     model_->AddGroup(model_->GetBookmarkBarNode(), 2, L"F2");
     model_->AddGroup(model_->GetBookmarkBarNode(), 3, L"F3");
-    BookmarkNode* f4 =
+    const BookmarkNode* f4 =
         model_->AddGroup(model_->GetBookmarkBarNode(), 4, L"F4");
     model_->AddURL(f4, 0, L"f4a", GURL(test_base + "f4a"));
   }
@@ -101,7 +101,7 @@ class BookmarkContextMenuTest : public testing::Test {
 
 // Tests Deleting from the menu.
 TEST_F(BookmarkContextMenuTest, DeleteURL) {
-  std::vector<BookmarkNode*> nodes;
+  std::vector<const BookmarkNode*> nodes;
   nodes.push_back(model_->GetBookmarkBarNode()->GetChild(0));
   BookmarkContextMenu controller(
       NULL, profile_.get(), NULL, NULL, nodes[0]->GetParent(), nodes,
@@ -116,7 +116,7 @@ TEST_F(BookmarkContextMenuTest, DeleteURL) {
 
 // Tests open all on a folder with a couple of bookmarks.
 TEST_F(BookmarkContextMenuTest, OpenAll) {
-  BookmarkNode* folder = model_->GetBookmarkBarNode()->GetChild(1);
+  const BookmarkNode* folder = model_->GetBookmarkBarNode()->GetChild(1);
   bookmark_utils::OpenAll(
       NULL, profile_.get(), &navigator_, folder, NEW_FOREGROUND_TAB);
 
@@ -131,7 +131,7 @@ TEST_F(BookmarkContextMenuTest, OpenAll) {
 TEST_F(BookmarkContextMenuTest, EmptyNodes) {
   BookmarkContextMenu controller(
       NULL, profile_.get(), NULL, NULL, model_->other_node(),
-      std::vector<BookmarkNode*>(), BookmarkContextMenu::BOOKMARK_BAR);
+      std::vector<const BookmarkNode*>(), BookmarkContextMenu::BOOKMARK_BAR);
   EXPECT_FALSE(controller.IsCommandEnabled(IDS_BOOMARK_BAR_OPEN_ALL));
   EXPECT_FALSE(
       controller.IsCommandEnabled(IDS_BOOMARK_BAR_OPEN_ALL_NEW_WINDOW));
@@ -148,7 +148,7 @@ TEST_F(BookmarkContextMenuTest, EmptyNodes) {
 // Tests the enabled state of the menus when supplied a vector with a single
 // url.
 TEST_F(BookmarkContextMenuTest, SingleURL) {
-  std::vector<BookmarkNode*> nodes;
+  std::vector<const BookmarkNode*> nodes;
   nodes.push_back(model_->GetBookmarkBarNode()->GetChild(0));
   BookmarkContextMenu controller(
       NULL, profile_.get(), NULL, NULL, nodes[0]->GetParent(),
@@ -169,7 +169,7 @@ TEST_F(BookmarkContextMenuTest, SingleURL) {
 // Tests the enabled state of the menus when supplied a vector with multiple
 // urls.
 TEST_F(BookmarkContextMenuTest, MultipleURLs) {
-  std::vector<BookmarkNode*> nodes;
+  std::vector<const BookmarkNode*> nodes;
   nodes.push_back(model_->GetBookmarkBarNode()->GetChild(0));
   nodes.push_back(model_->GetBookmarkBarNode()->GetChild(1)->GetChild(0));
   BookmarkContextMenu controller(
@@ -191,7 +191,7 @@ TEST_F(BookmarkContextMenuTest, MultipleURLs) {
 // Tests the enabled state of the menus when supplied an vector with a single
 // folder.
 TEST_F(BookmarkContextMenuTest, SingleFolder) {
-  std::vector<BookmarkNode*> nodes;
+  std::vector<const BookmarkNode*> nodes;
   nodes.push_back(model_->GetBookmarkBarNode()->GetChild(2));
   BookmarkContextMenu controller(
       NULL, profile_.get(), NULL, NULL, nodes[0]->GetParent(),
@@ -212,7 +212,7 @@ TEST_F(BookmarkContextMenuTest, SingleFolder) {
 // Tests the enabled state of the menus when supplied a vector with multiple
 // folders, all of which are empty.
 TEST_F(BookmarkContextMenuTest, MultipleEmptyFolders) {
-  std::vector<BookmarkNode*> nodes;
+  std::vector<const BookmarkNode*> nodes;
   nodes.push_back(model_->GetBookmarkBarNode()->GetChild(2));
   nodes.push_back(model_->GetBookmarkBarNode()->GetChild(3));
   BookmarkContextMenu controller(
@@ -234,7 +234,7 @@ TEST_F(BookmarkContextMenuTest, MultipleEmptyFolders) {
 // Tests the enabled state of the menus when supplied a vector with multiple
 // folders, some of which contain URLs.
 TEST_F(BookmarkContextMenuTest, MultipleFoldersWithURLs) {
-  std::vector<BookmarkNode*> nodes;
+  std::vector<const BookmarkNode*> nodes;
   nodes.push_back(model_->GetBookmarkBarNode()->GetChild(3));
   nodes.push_back(model_->GetBookmarkBarNode()->GetChild(4));
   BookmarkContextMenu controller(
@@ -255,7 +255,7 @@ TEST_F(BookmarkContextMenuTest, MultipleFoldersWithURLs) {
 
 // Tests the enabled state of open incognito.
 TEST_F(BookmarkContextMenuTest, DisableIncognito) {
-  std::vector<BookmarkNode*> nodes;
+  std::vector<const BookmarkNode*> nodes;
   nodes.push_back(model_->GetBookmarkBarNode()->GetChild(0));
   BookmarkContextMenu controller(
       NULL, profile_.get(), NULL, NULL, nodes[0]->GetParent(),
@@ -267,7 +267,7 @@ TEST_F(BookmarkContextMenuTest, DisableIncognito) {
 
 // Tests that you can't remove/edit when showing the other node.
 TEST_F(BookmarkContextMenuTest, DisabledItemsWithOtherNode) {
-  std::vector<BookmarkNode*> nodes;
+  std::vector<const BookmarkNode*> nodes;
   nodes.push_back(model_->other_node());
   BookmarkContextMenu controller(
       NULL, profile_.get(), NULL, NULL, nodes[0], nodes,
@@ -280,7 +280,8 @@ TEST_F(BookmarkContextMenuTest, DisabledItemsWithOtherNode) {
 // parent.
 TEST_F(BookmarkContextMenuTest, EmptyNodesNullParent) {
   BookmarkContextMenu controller(
-      NULL, profile_.get(), NULL, NULL, NULL, std::vector<BookmarkNode*>(),
+      NULL, profile_.get(), NULL, NULL, NULL,
+      std::vector<const BookmarkNode*>(),
       BookmarkContextMenu::BOOKMARK_MANAGER_ORGANIZE_MENU);
   EXPECT_FALSE(controller.IsCommandEnabled(IDS_BOOMARK_BAR_OPEN_ALL));
   EXPECT_FALSE(
diff --git a/chrome/browser/views/bookmark_editor_view.cc b/chrome/browser/views/bookmark_editor_view.cc
index 3208099..ed51083 100644
--- a/chrome/browser/views/bookmark_editor_view.cc
+++ b/chrome/browser/views/bookmark_editor_view.cc
@@ -47,8 +47,8 @@ static const int kNewGroupButtonID             = 1002;
 // static
 void BookmarkEditor::Show(HWND parent_hwnd,
                           Profile* profile,
-                          BookmarkNode* parent,
-                          BookmarkNode* node,
+                          const BookmarkNode* parent,
+                          const BookmarkNode* node,
                           Configuration configuration,
                           Handler* handler) {
   DCHECK(profile);
@@ -59,8 +59,8 @@ void BookmarkEditor::Show(HWND parent_hwnd,
 
 BookmarkEditorView::BookmarkEditorView(
     Profile* profile,
-    BookmarkNode* parent,
-    BookmarkNode* node,
+    const BookmarkNode* parent,
+    const BookmarkNode* node,
     BookmarkEditor::Configuration configuration,
     BookmarkEditor::Handler* handler)
     : profile_(profile),
@@ -339,23 +339,23 @@ void BookmarkEditorView::Init() {
 }
 
 void BookmarkEditorView::BookmarkNodeMoved(BookmarkModel* model,
-                                           BookmarkNode* old_parent,
+                                           const BookmarkNode* old_parent,
                                            int old_index,
-                                           BookmarkNode* new_parent,
+                                           const BookmarkNode* new_parent,
                                            int new_index) {
   Reset();
 }
 
 void BookmarkEditorView::BookmarkNodeAdded(BookmarkModel* model,
-                                           BookmarkNode* parent,
+                                           const BookmarkNode* parent,
                                            int index) {
   Reset();
 }
 
 void BookmarkEditorView::BookmarkNodeRemoved(BookmarkModel* model,
-                                             BookmarkNode* parent,
+                                             const BookmarkNode* parent,
                                              int index,
-                                             BookmarkNode* node) {
+                                             const BookmarkNode* node) {
   if ((node_ && node_->HasAncestor(node)) ||
       (parent_ && parent_->HasAncestor(node))) {
     // The node, or its parent was removed. Close the dialog.
@@ -365,8 +365,8 @@ void BookmarkEditorView::BookmarkNodeRemoved(BookmarkModel* model,
   }
 }
 
-void BookmarkEditorView::BookmarkNodeChildrenReordered(BookmarkModel* model,
-                                                       BookmarkNode* node) {
+void BookmarkEditorView::BookmarkNodeChildrenReordered(
+    BookmarkModel* model, const BookmarkNode* node) {
   Reset();
 }
 
@@ -440,7 +440,7 @@ BookmarkEditorView::EditorNode* BookmarkEditorView::AddNewGroup(
 void BookmarkEditorView::ExpandAndSelect() {
   tree_view_->ExpandAll();
 
-  BookmarkNode* to_select = node_ ? node_->GetParent() : parent_;
+  const BookmarkNode* to_select = node_ ? node_->GetParent() : parent_;
   int group_id_to_select = to_select->id();
   DCHECK(group_id_to_select);  // GetMostRecentParent should never return NULL.
   EditorNode* b_node =
@@ -453,7 +453,7 @@ void BookmarkEditorView::ExpandAndSelect() {
 
 BookmarkEditorView::EditorNode* BookmarkEditorView::CreateRootNode() {
   EditorNode* root_node = new EditorNode(std::wstring(), 0);
-  BookmarkNode* bb_root_node = bb_model_->root_node();
+  const 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() ==
@@ -462,10 +462,10 @@ BookmarkEditorView::EditorNode* BookmarkEditorView::CreateRootNode() {
   return root_node;
 }
 
-void BookmarkEditorView::CreateNodes(BookmarkNode* bb_node,
+void BookmarkEditorView::CreateNodes(const BookmarkNode* bb_node,
                                      BookmarkEditorView::EditorNode* b_node) {
   for (int i = 0; i < bb_node->GetChildCount(); ++i) {
-    BookmarkNode* child_bb_node = bb_node->GetChild(i);
+    const BookmarkNode* child_bb_node = bb_node->GetChild(i);
     if (child_bb_node->is_folder()) {
       EditorNode* new_b_node = new EditorNode(child_bb_node->GetTitle(),
                                                   child_bb_node->id());
@@ -518,7 +518,7 @@ void BookmarkEditorView::ApplyEdits(EditorNode* parent) {
   }
 
   // Create the new groups and update the titles.
-  BookmarkNode* new_parent = NULL;
+  const BookmarkNode* new_parent = NULL;
   ApplyNameChangesAndCreateNewGroups(
       bb_model_->root_node(), tree_model_->GetRoot(), parent, &new_parent);
 
@@ -527,15 +527,15 @@ void BookmarkEditorView::ApplyEdits(EditorNode* parent) {
 }
 
 void BookmarkEditorView::ApplyNameChangesAndCreateNewGroups(
-    BookmarkNode* bb_node,
+    const BookmarkNode* bb_node,
     BookmarkEditorView::EditorNode* b_node,
     BookmarkEditorView::EditorNode* parent_b_node,
-    BookmarkNode** parent_bb_node) {
+    const BookmarkNode** parent_bb_node) {
   if (parent_b_node == b_node)
     *parent_bb_node = bb_node;
   for (int i = 0; i < b_node->GetChildCount(); ++i) {
     EditorNode* child_b_node = b_node->GetChild(i);
-    BookmarkNode* child_bb_node = NULL;
+    const BookmarkNode* child_bb_node = NULL;
     if (child_b_node->value == 0) {
       // New group.
       child_bb_node = bb_model_->AddGroup(bb_node,
@@ -544,7 +544,7 @@ void BookmarkEditorView::ApplyNameChangesAndCreateNewGroups(
       // Existing node, reset the title (BBModel ignores changes if the title
       // is the same).
       for (int j = 0; j < bb_node->GetChildCount(); ++j) {
-        BookmarkNode* node = bb_node->GetChild(j);
+        const BookmarkNode* node = bb_node->GetChild(j);
         if (node->is_folder() && node->id() == child_b_node->value) {
           child_bb_node = node;
           break;
diff --git a/chrome/browser/views/bookmark_editor_view.h b/chrome/browser/views/bookmark_editor_view.h
index 51ef925..a03d3e9 100644
--- a/chrome/browser/views/bookmark_editor_view.h
+++ b/chrome/browser/views/bookmark_editor_view.h
@@ -54,8 +54,8 @@ class BookmarkEditorView : public BookmarkEditor,
   FRIEND_TEST(BookmarkEditorViewTest, ChangeTitleNoTree);
  public:
   BookmarkEditorView(Profile* profile,
-                     BookmarkNode* parent,
-                     BookmarkNode* node,
+                     const BookmarkNode* parent,
+                     const BookmarkNode* node,
                      BookmarkEditor::Configuration configuration,
                      BookmarkEditor::Handler* handler);
 
@@ -140,23 +140,23 @@ class BookmarkEditorView : public BookmarkEditor,
   // resetting the tree model.
   virtual void Loaded(BookmarkModel* model) { }
   virtual void BookmarkNodeMoved(BookmarkModel* model,
-                                 BookmarkNode* old_parent,
+                                 const BookmarkNode* old_parent,
                                  int old_index,
-                                 BookmarkNode* new_parent,
+                                 const BookmarkNode* new_parent,
                                  int new_index);
   virtual void BookmarkNodeAdded(BookmarkModel* model,
-                                 BookmarkNode* parent,
+                                 const BookmarkNode* parent,
                                  int index);
   virtual void BookmarkNodeRemoved(BookmarkModel* model,
-                                   BookmarkNode* parent,
+                                   const BookmarkNode* parent,
                                    int index,
-                                   BookmarkNode* node);
+                                   const BookmarkNode* node);
   virtual void BookmarkNodeChanged(BookmarkModel* model,
-                                   BookmarkNode* node) {}
+                                   const BookmarkNode* node) {}
   virtual void BookmarkNodeChildrenReordered(BookmarkModel* model,
-                                             BookmarkNode* node);
+                                             const BookmarkNode* node);
   virtual void BookmarkNodeFavIconLoaded(BookmarkModel* model,
-                                         BookmarkNode* node) {}
+                                         const BookmarkNode* node) {}
 
   // Resets the model of the tree and updates the various buttons appropriately.
   void Reset();
@@ -172,7 +172,7 @@ class BookmarkEditorView : public BookmarkEditor,
 
   // Adds and creates a child node in b_node for all children of bb_node that
   // are groups.
-  void CreateNodes(BookmarkNode* bb_node, EditorNode* b_node);
+  void CreateNodes(const BookmarkNode* bb_node, EditorNode* b_node);
 
   // Returns the node with the specified id, or NULL if one can't be found.
   EditorNode* FindNodeWithID(BookmarkEditorView::EditorNode* node, int id);
@@ -194,10 +194,10 @@ class BookmarkEditorView : public BookmarkEditor,
   // used to determine the new BookmarkNode parent based on the EditorNode
   // parent.
   void ApplyNameChangesAndCreateNewGroups(
-      BookmarkNode* bb_node,
+      const BookmarkNode* bb_node,
       BookmarkEditorView::EditorNode* b_node,
       BookmarkEditorView::EditorNode* parent_b_node,
-      BookmarkNode** parent_bb_node);
+      const BookmarkNode** parent_bb_node);
 
   // Returns the current url the user has input.
   GURL GetInputURL() const;
@@ -238,10 +238,10 @@ class BookmarkEditorView : public BookmarkEditor,
   views::Textfield title_tf_;
 
   // Initial parent to select. Is only used if node_ is NULL.
-  BookmarkNode* parent_;
+  const BookmarkNode* parent_;
 
   // Node being edited. Is NULL if creating a new node.
-  BookmarkNode* node_;
+  const BookmarkNode* node_;
 
   // The context menu.
   scoped_ptr<views::SimpleMenuModel> context_menu_contents_;
diff --git a/chrome/browser/views/bookmark_editor_view_unittest.cc b/chrome/browser/views/bookmark_editor_view_unittest.cc
index 4024c34..22570bb 100644
--- a/chrome/browser/views/bookmark_editor_view_unittest.cc
+++ b/chrome/browser/views/bookmark_editor_view_unittest.cc
@@ -41,10 +41,14 @@ class BookmarkEditorViewTest : public testing::Test {
 
   std::string base_path() const { return "file:///c:/tmp/"; }
 
-  BookmarkNode* GetNode(const std::string& name) {
+  const BookmarkNode* GetNode(const std::string& name) {
     return model_->GetMostRecentlyAddedNodeForURL(GURL(base_path() + name));
   }
 
+  BookmarkNode* GetMutableNode(const std::string& name) {
+    return const_cast<BookmarkNode*>(GetNode(name));
+  }
+
  private:
   // Creates the following structure:
   // bookmark bar node
@@ -63,16 +67,18 @@ class BookmarkEditorViewTest : public testing::Test {
 
     model_->AddURL(model_->GetBookmarkBarNode(), 0, L"a",
                    GURL(test_base + "a"));
-    BookmarkNode* f1 = model_->AddGroup(model_->GetBookmarkBarNode(), 1, L"F1");
+    const BookmarkNode* f1 =
+        model_->AddGroup(model_->GetBookmarkBarNode(), 1, L"F1");
     model_->AddURL(f1, 0, L"f1a", GURL(test_base + "f1a"));
-    BookmarkNode* f11 = model_->AddGroup(f1, 1, L"F11");
+    const BookmarkNode* f11 = model_->AddGroup(f1, 1, L"F11");
     model_->AddURL(f11, 0, L"f11a", GURL(test_base + "f11a"));
     model_->AddGroup(model_->GetBookmarkBarNode(), 2, L"F2");
 
     // Children of the other node.
     model_->AddURL(model_->other_node(), 0, L"oa",
                    GURL(test_base + "oa"));
-    BookmarkNode* of1 = model_->AddGroup(model_->other_node(), 1, L"OF1");
+    const BookmarkNode* of1 =
+        model_->AddGroup(model_->other_node(), 1, L"OF1");
     model_->AddURL(of1, 0, L"of1a", GURL(test_base + "of1a"));
   }
 };
@@ -110,7 +116,8 @@ TEST_F(BookmarkEditorViewTest, EditTitleKeepsPosition) {
 
   editor.ApplyEdits(editor.tree_model_->GetRoot()->GetChild(0));
 
-  BookmarkNode* bb_node = profile_->GetBookmarkModel()->GetBookmarkBarNode();
+  const BookmarkNode* bb_node =
+      profile_->GetBookmarkModel()->GetBookmarkBarNode();
   ASSERT_EQ(L"new_a", bb_node->GetChild(0)->GetTitle());
   // The URL shouldn't have changed.
   ASSERT_TRUE(GURL(base_path() + "a") == bb_node->GetChild(0)->GetURL());
@@ -119,7 +126,7 @@ TEST_F(BookmarkEditorViewTest, EditTitleKeepsPosition) {
 // Changes the url and makes sure parent/visual order doesn't change.
 TEST_F(BookmarkEditorViewTest, EditURLKeepsPosition) {
   Time node_time = Time::Now() + TimeDelta::FromDays(2);
-  GetNode("a")->date_added_ = node_time;
+  GetMutableNode("a")->set_date_added(node_time);
   BookmarkEditorView editor(profile_.get(), NULL, GetNode("a"),
                             BookmarkEditorView::SHOW_TREE, NULL);
 
@@ -127,7 +134,8 @@ TEST_F(BookmarkEditorViewTest, EditURLKeepsPosition) {
 
   editor.ApplyEdits(editor.tree_model_->GetRoot()->GetChild(0));
 
-  BookmarkNode* bb_node = profile_->GetBookmarkModel()->GetBookmarkBarNode();
+  const BookmarkNode* bb_node =
+      profile_->GetBookmarkModel()->GetBookmarkBarNode();
   ASSERT_EQ(L"a", bb_node->GetChild(0)->GetTitle());
   // The URL should have changed.
   ASSERT_TRUE(GURL(base_path() + "new_a") == bb_node->GetChild(0)->GetURL());
@@ -141,7 +149,7 @@ TEST_F(BookmarkEditorViewTest, ChangeParent) {
 
   editor.ApplyEdits(editor.tree_model_->GetRoot()->GetChild(1));
 
-  BookmarkNode* other_node = profile_->GetBookmarkModel()->other_node();
+  const BookmarkNode* other_node = profile_->GetBookmarkModel()->other_node();
   ASSERT_EQ(L"a", other_node->GetChild(2)->GetTitle());
   ASSERT_TRUE(GURL(base_path() + "a") == other_node->GetChild(2)->GetURL());
 }
@@ -149,7 +157,7 @@ TEST_F(BookmarkEditorViewTest, ChangeParent) {
 // Moves 'a' to be a child of the other node and changes its url to new_a.
 TEST_F(BookmarkEditorViewTest, ChangeParentAndURL) {
   Time node_time = Time::Now() + TimeDelta::FromDays(2);
-  GetNode("a")->date_added_ = node_time;
+  GetMutableNode("a")->set_date_added(node_time);
   BookmarkEditorView editor(profile_.get(), NULL, GetNode("a"),
                             BookmarkEditorView::SHOW_TREE, NULL);
 
@@ -157,7 +165,7 @@ TEST_F(BookmarkEditorViewTest, ChangeParentAndURL) {
 
   editor.ApplyEdits(editor.tree_model_->GetRoot()->GetChild(1));
 
-  BookmarkNode* other_node = profile_->GetBookmarkModel()->other_node();
+  const BookmarkNode* other_node = profile_->GetBookmarkModel()->other_node();
   ASSERT_EQ(L"a", other_node->GetChild(2)->GetTitle());
   ASSERT_TRUE(GURL(base_path() + "new_a") == other_node->GetChild(2)->GetURL());
   ASSERT_TRUE(node_time == other_node->GetChild(2)->date_added());
@@ -179,8 +187,9 @@ TEST_F(BookmarkEditorViewTest, MoveToNewParent) {
   // Parent the node to "F21".
   editor.ApplyEdits(f2);
 
-  BookmarkNode* bb_node = profile_->GetBookmarkModel()->GetBookmarkBarNode();
-  BookmarkNode* mf2 = bb_node->GetChild(1);
+  const BookmarkNode* bb_node =
+      profile_->GetBookmarkModel()->GetBookmarkBarNode();
+  const BookmarkNode* mf2 = bb_node->GetChild(1);
 
   // F2 in the model should have two children now: F21 and the node edited.
   ASSERT_EQ(2, mf2->GetChildCount());
@@ -190,7 +199,7 @@ TEST_F(BookmarkEditorViewTest, MoveToNewParent) {
   ASSERT_EQ(L"a", mf2->GetChild(1)->GetTitle());
 
   // F21 should have one child, F211.
-  BookmarkNode* mf21 = mf2->GetChild(0);
+  const BookmarkNode* mf21 = mf2->GetChild(0);
   ASSERT_EQ(1, mf21->GetChildCount());
   ASSERT_EQ(L"F211", mf21->GetChild(0)->GetTitle());
 }
@@ -205,10 +214,11 @@ TEST_F(BookmarkEditorViewTest, NewURL) {
 
   editor.ApplyEdits(editor.tree_model_->GetRoot()->GetChild(0));
 
-  BookmarkNode* bb_node = profile_->GetBookmarkModel()->GetBookmarkBarNode();
+  const BookmarkNode* bb_node =
+      profile_->GetBookmarkModel()->GetBookmarkBarNode();
   ASSERT_EQ(4, bb_node->GetChildCount());
 
-  BookmarkNode* new_node = bb_node->GetChild(3);
+  const BookmarkNode* new_node = bb_node->GetChild(3);
 
   EXPECT_EQ(L"new_a", new_node->GetTitle());
   EXPECT_TRUE(GURL(base_path() + "a") == new_node->GetURL());
@@ -225,10 +235,10 @@ TEST_F(BookmarkEditorViewTest, ChangeURLNoTree) {
 
   editor.ApplyEdits(NULL);
 
-  BookmarkNode* other_node = profile_->GetBookmarkModel()->other_node();
+  const BookmarkNode* other_node = profile_->GetBookmarkModel()->other_node();
   ASSERT_EQ(2, other_node->GetChildCount());
 
-  BookmarkNode* new_node = other_node->GetChild(0);
+  const BookmarkNode* new_node = other_node->GetChild(0);
 
   EXPECT_EQ(L"new_a", new_node->GetTitle());
   EXPECT_TRUE(GURL(base_path() + "a") == new_node->GetURL());
@@ -244,10 +254,10 @@ TEST_F(BookmarkEditorViewTest, ChangeTitleNoTree) {
 
   editor.ApplyEdits(NULL);
 
-  BookmarkNode* other_node = profile_->GetBookmarkModel()->other_node();
+  const BookmarkNode* other_node = profile_->GetBookmarkModel()->other_node();
   ASSERT_EQ(2, other_node->GetChildCount());
 
-  BookmarkNode* new_node = other_node->GetChild(0);
+  const BookmarkNode* new_node = other_node->GetChild(0);
 
   EXPECT_EQ(L"new_a", new_node->GetTitle());
 }
diff --git a/chrome/browser/views/bookmark_folder_tree_view.cc b/chrome/browser/views/bookmark_folder_tree_view.cc
index eda92f5..bd464c8 100644
--- a/chrome/browser/views/bookmark_folder_tree_view.cc
+++ b/chrome/browser/views/bookmark_folder_tree_view.cc
@@ -78,7 +78,7 @@ int BookmarkFolderTreeView::OnPerformDrop(const views::DropTargetEvent& event) {
   return drop_operation;
 }
 
-BookmarkNode* BookmarkFolderTreeView::GetSelectedBookmarkNode() {
+const BookmarkNode* BookmarkFolderTreeView::GetSelectedBookmarkNode() {
   TreeModelNode* selected_node = GetSelectedNode();
   if (!selected_node)
     return NULL;
@@ -113,7 +113,7 @@ int BookmarkFolderTreeView::UpdateDropInfo() {
   return drop_info_->drop_operation();
 }
 
-void BookmarkFolderTreeView::BeginDrag(BookmarkNode* node) {
+void BookmarkFolderTreeView::BeginDrag(const BookmarkNode* node) {
   BookmarkModel* model = profile_->GetBookmarkModel();
   // Only allow the drag if the user has selected a node of type bookmark and it
   // isn't the bookmark bar or other bookmarks folders.
@@ -122,7 +122,7 @@ void BookmarkFolderTreeView::BeginDrag(BookmarkNode* node) {
     return;
   }
 
-  std::vector<BookmarkNode*> nodes_to_drag;
+  std::vector<const BookmarkNode*> nodes_to_drag;
   nodes_to_drag.push_back(node);
 
   scoped_refptr<OSExchangeData> data = new OSExchangeData;
@@ -212,7 +212,7 @@ int BookmarkFolderTreeView::CalculateDropOperation(
 }
 
 void BookmarkFolderTreeView::OnPerformDropImpl() {
-  BookmarkNode* parent_node =
+  const BookmarkNode* parent_node =
       TreeNodeAsBookmarkNode(drop_info_->position().parent);
   int drop_index = FolderIndexToBookmarkIndex(drop_info_->position());
   BookmarkModel* model = profile_->GetBookmarkModel();
@@ -226,7 +226,8 @@ void BookmarkFolderTreeView::OnPerformDropImpl() {
   }
 
   // else, move.
-  std::vector<BookmarkNode*> nodes = drop_info_->data().GetNodes(profile_);
+  std::vector<const BookmarkNode*> nodes =
+      drop_info_->data().GetNodes(profile_);
   if (nodes.empty())
     return;
 
@@ -286,13 +287,14 @@ BookmarkFolderTreeModel* BookmarkFolderTreeView::folder_model() const {
   return static_cast<BookmarkFolderTreeModel*>(model());
 }
 
-BookmarkNode* BookmarkFolderTreeView::TreeNodeAsBookmarkNode(FolderNode* node) {
+const BookmarkNode* BookmarkFolderTreeView::TreeNodeAsBookmarkNode(
+    FolderNode* node) {
   return folder_model()->TreeNodeAsBookmarkNode(node);
 }
 
 int BookmarkFolderTreeView::FolderIndexToBookmarkIndex(
     const DropPosition& position) {
-  BookmarkNode* parent_node = TreeNodeAsBookmarkNode(position.parent);
+  const BookmarkNode* parent_node = TreeNodeAsBookmarkNode(position.parent);
   if (position.on || position.index == position.parent->GetChildCount())
     return parent_node->GetChildCount();
 
diff --git a/chrome/browser/views/bookmark_folder_tree_view.h b/chrome/browser/views/bookmark_folder_tree_view.h
index 2a47b1b..93f5205 100644
--- a/chrome/browser/views/bookmark_folder_tree_view.h
+++ b/chrome/browser/views/bookmark_folder_tree_view.h
@@ -32,7 +32,7 @@ class BookmarkFolderTreeView : public views::TreeView {
   // Returns the selected node as a BookmarkNode. This returns NULL if the
   // selected node is not of type BookmarkFolderTreeModel::BOOKMARK or
   // nothing is selected.
-  BookmarkNode* GetSelectedBookmarkNode();
+  const BookmarkNode* GetSelectedBookmarkNode();
 
  protected:
   // Overriden to start a drag.
@@ -96,7 +96,7 @@ class BookmarkFolderTreeView : public views::TreeView {
   int UpdateDropInfo();
 
   // Starts a drag operation for the specified node.
-  void BeginDrag(BookmarkNode* node);
+  void BeginDrag(const BookmarkNode* node);
 
   // Calculates the drop position.
   DropPosition CalculateDropPosition(int y, bool only_folders);
@@ -115,7 +115,7 @@ class BookmarkFolderTreeView : public views::TreeView {
   BookmarkFolderTreeModel* folder_model() const;
 
   // Converts FolderNode into a BookmarkNode.
-  BookmarkNode* TreeNodeAsBookmarkNode(FolderNode* node);
+  const BookmarkNode* TreeNodeAsBookmarkNode(FolderNode* node);
 
   // Converts the position in terms of the BookmarkFolderTreeModel to an index
   // in terms of the BookmarkModel. The returned index is the index the drop
diff --git a/chrome/browser/views/bookmark_manager_view.cc b/chrome/browser/views/bookmark_manager_view.cc
index 3582b86..b873249 100644
--- a/chrome/browser/views/bookmark_manager_view.cc
+++ b/chrome/browser/views/bookmark_manager_view.cc
@@ -80,7 +80,7 @@ class ImportObserverImpl : public ImportObserver {
     BookmarkModel* model = profile_->GetBookmarkModel();
     int other_count = model->other_node()->GetChildCount();
     if (other_count == initial_other_count_ + 1) {
-      BookmarkNode* imported_node =
+      const BookmarkNode* imported_node =
           model->other_node()->GetChild(initial_other_count_);
       manager->SelectInTree(imported_node);
       manager->ExpandAll(imported_node);
@@ -145,7 +145,7 @@ void ShowBookmarkManagerView(Profile* profile) {
 
 // BookmarkManager -------------------------------------------------------------
 
-void BookmarkManager::SelectInTree(Profile* profile, BookmarkNode* node) {
+void BookmarkManager::SelectInTree(Profile* profile, const BookmarkNode* node) {
   if (manager && manager->profile() == profile)
     manager->SelectInTree(node);
 }
@@ -276,11 +276,11 @@ BookmarkManagerView* BookmarkManagerView::current() {
   return manager;
 }
 
-void BookmarkManagerView::SelectInTree(BookmarkNode* node) {
+void BookmarkManagerView::SelectInTree(const BookmarkNode* node) {
   if (!node)
     return;
 
-  BookmarkNode* parent = node->is_url() ? node->GetParent() : node;
+  const BookmarkNode* parent = node->is_url() ? node->GetParent() : node;
   FolderNode* folder_node = tree_model_->GetFolderNodeForBookmarkNode(parent);
   if (!folder_node) {
     NOTREACHED();
@@ -298,8 +298,8 @@ void BookmarkManagerView::SelectInTree(BookmarkNode* node) {
   }
 }
 
-void BookmarkManagerView::ExpandAll(BookmarkNode* node) {
-  BookmarkNode* parent = node->is_url() ? node->GetParent() : node;
+void BookmarkManagerView::ExpandAll(const BookmarkNode* node) {
+  const BookmarkNode* parent = node->is_url() ? node->GetParent() : node;
   FolderNode* folder_node = tree_model_->GetFolderNodeForBookmarkNode(parent);
   if (!folder_node) {
     NOTREACHED();
@@ -308,12 +308,12 @@ void BookmarkManagerView::ExpandAll(BookmarkNode* node) {
   tree_view_->ExpandAll(folder_node);
 }
 
-BookmarkNode* BookmarkManagerView::GetSelectedFolder() {
+const BookmarkNode* BookmarkManagerView::GetSelectedFolder() {
   return tree_view_->GetSelectedBookmarkNode();
 }
 
-std::vector<BookmarkNode*> BookmarkManagerView::GetSelectedTableNodes() {
-  std::vector<BookmarkNode*> nodes;
+std::vector<const BookmarkNode*> BookmarkManagerView::GetSelectedTableNodes() {
+  std::vector<const BookmarkNode*> nodes;
   for (views::TableView::iterator i = table_view_->SelectionBegin();
        i != table_view_->SelectionEnd(); ++i) {
     nodes.push_back(table_model_->GetNodeForRow(*i));
@@ -362,7 +362,7 @@ bool BookmarkManagerView::AcceleratorPressed(
 }
 
 void BookmarkManagerView::OnDoubleClick() {
-  std::vector<BookmarkNode*> nodes = GetSelectedTableNodes();
+  std::vector<const BookmarkNode*> nodes = GetSelectedTableNodes();
   if (nodes.empty())
     return;
   if (nodes.size() == 1 && nodes[0]->is_folder()) {
@@ -378,7 +378,7 @@ void BookmarkManagerView::OnDoubleClick() {
 }
 
 void BookmarkManagerView::OnMiddleClick() {
-  std::vector<BookmarkNode*> nodes = GetSelectedTableNodes();
+  std::vector<const BookmarkNode*> nodes = GetSelectedTableNodes();
   if (nodes.empty())
     return;
   if (nodes.size() == 1 && nodes[0]->is_folder()) {
@@ -391,7 +391,7 @@ void BookmarkManagerView::OnMiddleClick() {
 }
 
 void BookmarkManagerView::OnTableViewDelete(views::TableView* table) {
-  std::vector<BookmarkNode*> nodes = GetSelectedTableNodes();
+  std::vector<const BookmarkNode*> nodes = GetSelectedTableNodes();
   if (nodes.empty())
     return;
   for (size_t i = 0; i < nodes.size(); ++i) {
@@ -403,7 +403,7 @@ void BookmarkManagerView::OnTableViewDelete(views::TableView* table) {
 void BookmarkManagerView::OnKeyDown(unsigned short virtual_keycode) {
   switch (virtual_keycode) {
     case VK_RETURN: {
-      std::vector<BookmarkNode*> selected_nodes = GetSelectedTableNodes();
+      std::vector<const BookmarkNode*> selected_nodes = GetSelectedTableNodes();
       if (selected_nodes.size() == 1 && selected_nodes[0]->is_folder()) {
         SelectInTree(selected_nodes[0]);
       } else {
@@ -415,7 +415,7 @@ void BookmarkManagerView::OnKeyDown(unsigned short virtual_keycode) {
     }
 
     case VK_BACK: {
-      BookmarkNode* selected_folder = GetSelectedFolder();
+      const BookmarkNode* selected_folder = GetSelectedFolder();
       if (selected_folder != NULL &&
           selected_folder->GetParent() != GetBookmarkModel()->root_node()) {
         SelectInTree(selected_folder->GetParent());
@@ -434,7 +434,7 @@ void BookmarkManagerView::OnTreeViewSelectionChanged(
   TreeModelNode* node = tree_view_->GetSelectedNode();
 
   BookmarkTableModel* new_table_model = NULL;
-  BookmarkNode* table_parent_node = NULL;
+  const BookmarkNode* table_parent_node = NULL;
   bool is_search = false;
 
   if (node) {
@@ -470,11 +470,11 @@ void BookmarkManagerView::OnTreeViewSelectionChanged(
 void BookmarkManagerView::OnTreeViewKeyDown(unsigned short virtual_keycode) {
   switch (virtual_keycode) {
     case VK_DELETE: {
-      BookmarkNode* node = GetSelectedFolder();
+      const BookmarkNode* node = GetSelectedFolder();
       if (!node || node->GetParent() == GetBookmarkModel()->root_node())
         return;
 
-      BookmarkNode* parent = node->GetParent();
+      const BookmarkNode* parent = node->GetParent();
       GetBookmarkModel()->Remove(parent, parent->IndexOfChild(node));
       break;
     }
@@ -599,7 +599,7 @@ BookmarkTableModel* BookmarkManagerView::CreateSearchTableModel() {
 }
 
 void BookmarkManagerView::SetTableModel(BookmarkTableModel* new_table_model,
-                                        BookmarkNode* parent_node,
+                                        const BookmarkNode* parent_node,
                                         bool is_search) {
   // Be sure and reset the model on the view before updating table_model_.
   // Otherwise the view will attempt to use the deleted model when we set the
@@ -656,7 +656,7 @@ void BookmarkManagerView::PrepareForShow() {
 
 void BookmarkManagerView::LoadedImpl() {
   BookmarkModel* bookmark_model = GetBookmarkModel();
-  BookmarkNode* bookmark_bar_node = bookmark_model->GetBookmarkBarNode();
+  const BookmarkNode* bookmark_bar_node = bookmark_model->GetBookmarkBarNode();
   table_model_.reset(
       BookmarkTableModel::CreateBookmarkTableModelForFolder(bookmark_model,
                                                             bookmark_bar_node));
@@ -693,8 +693,8 @@ void BookmarkManagerView::ShowMenu(
   if (config == BookmarkContextMenu::BOOKMARK_MANAGER_TABLE ||
       (config == BookmarkContextMenu::BOOKMARK_MANAGER_ORGANIZE_MENU &&
        table_view_->HasFocus())) {
-    std::vector<BookmarkNode*> nodes = GetSelectedTableNodes();
-    BookmarkNode* parent = GetSelectedFolder();
+    std::vector<const BookmarkNode*> nodes = GetSelectedTableNodes();
+    const BookmarkNode* parent = GetSelectedFolder();
     if (!parent) {
       if (config == BookmarkContextMenu::BOOKMARK_MANAGER_TABLE)
         config = BookmarkContextMenu::BOOKMARK_MANAGER_TABLE_OTHER;
@@ -705,8 +705,8 @@ void BookmarkManagerView::ShowMenu(
                              config);
     menu.RunMenuAt(x, y);
   } else {
-    BookmarkNode* node = GetSelectedFolder();
-    std::vector<BookmarkNode*> nodes;
+    const BookmarkNode* node = GetSelectedFolder();
+    std::vector<const BookmarkNode*> nodes;
     if (node)
       nodes.push_back(node);
     BookmarkContextMenu menu(GetWidget()->GetNativeView(), profile_, NULL, NULL,
@@ -718,11 +718,11 @@ void BookmarkManagerView::ShowMenu(
 void BookmarkManagerView::OnCutCopyPaste(CutCopyPasteType type,
                                          bool from_table) {
   if (type == CUT || type == COPY) {
-    std::vector<BookmarkNode*> nodes;
+    std::vector<const BookmarkNode*> nodes;
     if (from_table) {
       nodes = GetSelectedTableNodes();
     } else {
-      BookmarkNode* node = GetSelectedFolder();
+      const BookmarkNode* node = GetSelectedFolder();
       if (!node || node->GetParent() == GetBookmarkModel()->root_node())
         return;
       nodes.push_back(node);
diff --git a/chrome/browser/views/bookmark_manager_view.h b/chrome/browser/views/bookmark_manager_view.h
index 2139a0b..a8f3ca6 100644
--- a/chrome/browser/views/bookmark_manager_view.h
+++ b/chrome/browser/views/bookmark_manager_view.h
@@ -62,16 +62,16 @@ class BookmarkManagerView : public views::View,
 
   // Selects the specified node in the tree. If node is a URL it's parent is
   // selected and node is selected in the table.
-  void SelectInTree(BookmarkNode* node);
+  void SelectInTree(const BookmarkNode* node);
 
   // Expands all the children of the selected folder.
-  void ExpandAll(BookmarkNode* node);
+  void ExpandAll(const BookmarkNode* node);
 
   // Returns the selected folder in the tree, which may be null.
-  BookmarkNode* GetSelectedFolder();
+  const BookmarkNode* GetSelectedFolder();
 
   // Returns the selection of the table.
-  std::vector<BookmarkNode*> GetSelectedTableNodes();
+  std::vector<const BookmarkNode*> GetSelectedTableNodes();
 
   virtual void PaintBackground(gfx::Canvas* canvas);
 
@@ -112,26 +112,26 @@ class BookmarkManagerView : public views::View,
   virtual void Loaded(BookmarkModel* model);
   virtual void BookmarkModelBeingDeleted(BookmarkModel* model) {}
   virtual void BookmarkNodeMoved(BookmarkModel* model,
-                                 BookmarkNode* old_parent,
+                                 const BookmarkNode* old_parent,
                                  int old_index,
-                                 BookmarkNode* new_parent,
+                                 const BookmarkNode* new_parent,
                                  int new_index) {}
   virtual void BookmarkNodeAdded(BookmarkModel* model,
-                                 BookmarkNode* parent,
+                                 const BookmarkNode* parent,
                                  int index) {}
   virtual void BookmarkNodeRemoved(BookmarkModel* model,
-                                   BookmarkNode* parent,
+                                   const BookmarkNode* parent,
                                    int index) {}
   virtual void BookmarkNodeRemoved(BookmarkModel* model,
-                                   BookmarkNode* parent,
+                                   const BookmarkNode* parent,
                                    int old_index,
-                                   BookmarkNode* node) {}
+                                   const BookmarkNode* node) {}
   virtual void BookmarkNodeChanged(BookmarkModel* model,
-                                   BookmarkNode* node) {}
+                                   const BookmarkNode* node) {}
   virtual void BookmarkNodeChildrenReordered(BookmarkModel* model,
-                                             BookmarkNode* node) {}
+                                             const BookmarkNode* node) {}
   virtual void BookmarkNodeFavIconLoaded(BookmarkModel* model,
-                                         BookmarkNode* node) {}
+                                         const BookmarkNode* node) {}
 
   // Textfield::Controller methods.
   // Starts a timer to search for the search text.
@@ -165,7 +165,7 @@ class BookmarkManagerView : public views::View,
   // Sets the model of the table and its parent node. If |is_search| is true,
   // it means the table is showing search results.
   void SetTableModel(BookmarkTableModel* new_table_model,
-                     BookmarkNode* parent_node,
+                     const BookmarkNode* parent_node,
                      bool is_search);
 
   // Sets the table's model to the results of CreateSearchTableModel and selects
diff --git a/chrome/browser/views/bookmark_menu_button.cc b/chrome/browser/views/bookmark_menu_button.cc
index 2b299cb..4a4889b 100644
--- a/chrome/browser/views/bookmark_menu_button.cc
+++ b/chrome/browser/views/bookmark_menu_button.cc
@@ -89,7 +89,7 @@ int BookmarkMenuButton::OnPerformDrop(const views::DropTargetEvent& event) {
   if (!model)
     return DragDropTypes::DRAG_NONE;
 
-  BookmarkNode* parent = model->GetBookmarkBarNode();
+  const BookmarkNode* parent = model->GetBookmarkBarNode();
   return bookmark_utils::PerformBookmarkDrop(
       browser_->profile(), data, parent, parent->GetChildCount());
 }
diff --git a/chrome/browser/views/bookmark_menu_controller_views.cc b/chrome/browser/views/bookmark_menu_controller_views.cc
index cd550ca..5fc5c97 100644
--- a/chrome/browser/views/bookmark_menu_controller_views.cc
+++ b/chrome/browser/views/bookmark_menu_controller_views.cc
@@ -22,7 +22,7 @@ BookmarkMenuController::BookmarkMenuController(Browser* browser,
                                                Profile* profile,
                                                PageNavigator* navigator,
                                                gfx::NativeView parent,
-                                               BookmarkNode* node,
+                                               const BookmarkNode* node,
                                                int start_child_index,
                                                bool show_other_folder)
     : browser_(browser),
@@ -84,7 +84,7 @@ bool BookmarkMenuController::CanDrop(views::MenuItemView* menu,
   if (drop_data_.has_single_url())
     return true;
 
-  BookmarkNode* drag_node = drop_data_.GetFirstNode(profile_);
+  const BookmarkNode* drag_node = drop_data_.GetFirstNode(profile_);
   if (!drag_node) {
     // Dragging a group from another profile, always accept.
     return true;
@@ -92,7 +92,7 @@ bool BookmarkMenuController::CanDrop(views::MenuItemView* menu,
 
   // 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.
-  BookmarkNode* drop_node = menu_id_to_node_map_[menu->GetCommand()];
+  const BookmarkNode* drop_node = menu_id_to_node_map_[menu->GetCommand()];
   DCHECK(drop_node);
   while (drop_node && drop_node != drag_node)
     drop_node = drop_node->GetParent();
@@ -106,8 +106,8 @@ int BookmarkMenuController::GetDropOperation(
   // Should only get here if we have drop data.
   DCHECK(drop_data_.is_valid());
 
-  BookmarkNode* node = menu_id_to_node_map_[item->GetCommand()];
-  BookmarkNode* drop_parent = node->GetParent();
+  const BookmarkNode* node = menu_id_to_node_map_[item->GetCommand()];
+  const BookmarkNode* drop_parent = node->GetParent();
   int index_to_drop_at = drop_parent->IndexOfChild(node);
   if (*position == DROP_AFTER) {
     if (node == profile_->GetBookmarkModel()->other_node()) {
@@ -128,11 +128,11 @@ int BookmarkMenuController::GetDropOperation(
 int BookmarkMenuController::OnPerformDrop(views::MenuItemView* menu,
                                           DropPosition position,
                                           const views::DropTargetEvent& event) {
-  BookmarkNode* drop_node = menu_id_to_node_map_[menu->GetCommand()];
+  const BookmarkNode* drop_node = menu_id_to_node_map_[menu->GetCommand()];
   DCHECK(drop_node);
   BookmarkModel* model = profile_->GetBookmarkModel();
   DCHECK(model);
-  BookmarkNode* drop_parent = drop_node->GetParent();
+  const BookmarkNode* drop_parent = drop_node->GetParent();
   DCHECK(drop_parent);
   int index_to_drop_at = drop_parent->IndexOfChild(drop_node);
   if (position == DROP_AFTER) {
@@ -156,7 +156,7 @@ bool BookmarkMenuController::ShowContextMenu(views::MenuItemView* source,
                                              int y,
                                              bool is_mouse_gesture) {
   DCHECK(menu_id_to_node_map_.find(id) != menu_id_to_node_map_.end());
-  std::vector<BookmarkNode*> nodes;
+  std::vector<const BookmarkNode*> nodes;
   nodes.push_back(menu_id_to_node_map_[id]);
   context_menu_.reset(
       new BookmarkContextMenu(parent_,
@@ -176,7 +176,7 @@ void BookmarkMenuController::DropMenuClosed(views::MenuItemView* menu) {
 }
 
 bool BookmarkMenuController::CanDrag(views::MenuItemView* menu) {
-  BookmarkNode* node = menu_id_to_node_map_[menu->GetCommand()];
+  const BookmarkNode* node = menu_id_to_node_map_[menu->GetCommand()];
   // Don't let users drag the other folder.
   return node->GetParent() != profile_->GetBookmarkModel()->root_node();
 }
@@ -200,14 +200,14 @@ void BookmarkMenuController::BookmarkModelChanged() {
   menu_->Cancel();
 }
 
-void BookmarkMenuController::BookmarkNodeFavIconLoaded(BookmarkModel* model,
-                                                       BookmarkNode* node) {
+void BookmarkMenuController::BookmarkNodeFavIconLoaded(
+    BookmarkModel* model, const BookmarkNode* node) {
   if (node_to_menu_id_map_.find(node) != node_to_menu_id_map_.end())
     menu_->SetIcon(model->GetFavIcon(node), node_to_menu_id_map_[node]);
 }
 
 void BookmarkMenuController::BuildOtherFolderMenu(int* next_menu_id) {
-  BookmarkNode* other_folder = profile_->GetBookmarkModel()->other_node();
+  const BookmarkNode* other_folder = profile_->GetBookmarkModel()->other_node();
   int id = *next_menu_id;
   (*next_menu_id)++;
   SkBitmap* folder_icon = ResourceBundle::GetSharedInstance().
@@ -218,14 +218,14 @@ void BookmarkMenuController::BuildOtherFolderMenu(int* next_menu_id) {
   menu_id_to_node_map_[id] = other_folder;
 }
 
-void BookmarkMenuController::BuildMenu(BookmarkNode* parent,
+void BookmarkMenuController::BuildMenu(const BookmarkNode* parent,
                                        int start_child_index,
                                        views::MenuItemView* menu,
                                        int* next_menu_id) {
   DCHECK(!parent->GetChildCount() ||
          start_child_index < parent->GetChildCount());
   for (int i = start_child_index; i < parent->GetChildCount(); ++i) {
-    BookmarkNode* node = parent->GetChild(i);
+    const BookmarkNode* node = parent->GetChild(i);
     int id = *next_menu_id;
 
     (*next_menu_id)++;
diff --git a/chrome/browser/views/bookmark_menu_controller_views.h b/chrome/browser/views/bookmark_menu_controller_views.h
index a87ecfe..e9bd5d3 100644
--- a/chrome/browser/views/bookmark_menu_controller_views.h
+++ b/chrome/browser/views/bookmark_menu_controller_views.h
@@ -39,7 +39,7 @@ class BookmarkMenuController : public BaseBookmarkModelObserver,
                          Profile* profile,
                          PageNavigator* page_navigator,
                          gfx::NativeView parent,
-                         BookmarkNode* node,
+                         const BookmarkNode* node,
                          int start_child_index,
                          bool show_other_folder);
 
@@ -52,7 +52,7 @@ class BookmarkMenuController : public BaseBookmarkModelObserver,
   void Cancel();
 
   // Returns the node the menu is showing for.
-  BookmarkNode* node() const { return node_; }
+  const BookmarkNode* node() const { return node_; }
 
   // Returns the menu.
   views::MenuItemView* menu() const { return menu_.get(); }
@@ -86,7 +86,7 @@ class BookmarkMenuController : public BaseBookmarkModelObserver,
 
   virtual void BookmarkModelChanged();
   virtual void BookmarkNodeFavIconLoaded(BookmarkModel* model,
-                                         BookmarkNode* node);
+                                         const BookmarkNode* node);
 
  private:
   // BookmarkMenuController deletes itself as necessary.
@@ -98,7 +98,7 @@ class BookmarkMenuController : public BaseBookmarkModelObserver,
 
   // Creates an entry in menu for each child node of |parent| starting at
   // |start_child_index|.
-  void BuildMenu(BookmarkNode* parent,
+  void BuildMenu(const BookmarkNode* parent,
                  int start_child_index,
                  views::MenuItemView* menu,
                  int* next_menu_id);
@@ -113,14 +113,14 @@ class BookmarkMenuController : public BaseBookmarkModelObserver,
   gfx::NativeView parent_;
 
   // The node we're showing the contents of.
-  BookmarkNode* node_;
+  const BookmarkNode* node_;
 
   // Maps from menu id to BookmarkNode.
-  std::map<int, BookmarkNode*> menu_id_to_node_map_;
+  std::map<int, const BookmarkNode*> menu_id_to_node_map_;
 
   // Mapping from node to menu id. This only contains entries for nodes of type
   // URL.
-  std::map<BookmarkNode*, int> node_to_menu_id_map_;
+  std::map<const BookmarkNode*, int> node_to_menu_id_map_;
 
   // The menu.
   scoped_ptr<views::MenuItemView> menu_;
diff --git a/chrome/browser/views/bookmark_table_view.cc b/chrome/browser/views/bookmark_table_view.cc
index 7705d1b..3eaa2f3 100644
--- a/chrome/browser/views/bookmark_table_view.cc
+++ b/chrome/browser/views/bookmark_table_view.cc
@@ -64,7 +64,7 @@ bool BookmarkTableView::CanDrop(const OSExchangeData& data) {
 
   // Don't allow the user to drop an ancestor of the parent node onto the
   // parent node. This would create a cycle, which is definitely a no-no.
-  std::vector<BookmarkNode*> nodes = drag_data.GetNodes(profile_);
+  std::vector<const BookmarkNode*> nodes = drag_data.GetNodes(profile_);
   for (size_t i = 0; i < nodes.size(); ++i) {
     if (parent_node_->HasAncestor(nodes[i]))
       return false;
@@ -187,7 +187,7 @@ int BookmarkTableView::UpdateDropInfo() {
 }
 
 void BookmarkTableView::BeginDrag() {
-  std::vector<BookmarkNode*> nodes_to_drag;
+  std::vector<const BookmarkNode*> nodes_to_drag;
   for (TableView::iterator i = SelectionBegin(); i != SelectionEnd(); ++i)
     nodes_to_drag.push_back(bookmark_table_model()->GetNodeForRow(*i));
   if (nodes_to_drag.empty())
@@ -213,7 +213,7 @@ int BookmarkTableView::CalculateDropOperation(const DropPosition& position) {
       return DragDropTypes::DRAG_COPY;
 
     int real_drop_index;
-    BookmarkNode* drop_parent = GetDropParentAndIndex(position,
+    const BookmarkNode* drop_parent = GetDropParentAndIndex(position,
                                                       &real_drop_index);
     if (!bookmark_utils::IsValidDropLocation(
         profile_, drop_info_->data(), drop_parent, real_drop_index)) {
@@ -230,7 +230,7 @@ int BookmarkTableView::CalculateDropOperation(const DropPosition& position) {
 
 void BookmarkTableView::OnPerformDropImpl() {
   int drop_index;
-  BookmarkNode* drop_parent = GetDropParentAndIndex(
+  const BookmarkNode* drop_parent = GetDropParentAndIndex(
       drop_info_->position(), &drop_index);
   BookmarkModel* model = profile_->GetBookmarkModel();
   int min_selection;
@@ -246,7 +246,8 @@ void BookmarkTableView::OnPerformDropImpl() {
         static_cast<int>(drop_info_->data().elements.size());
   } else {
     // else, move.
-    std::vector<BookmarkNode*> nodes = drop_info_->data().GetNodes(profile_);
+    std::vector<const BookmarkNode*> nodes =
+        drop_info_->data().GetNodes(profile_);
     if (nodes.empty())
       return;
 
@@ -330,11 +331,11 @@ BookmarkTableView::DropPosition
   return DropPosition(row_count, false);
 }
 
-BookmarkNode* BookmarkTableView::GetDropParentAndIndex(
+const BookmarkNode* BookmarkTableView::GetDropParentAndIndex(
     const DropPosition& position,
     int* index) {
   if (position.on) {
-    BookmarkNode* parent = parent_node_->GetChild(position.index);
+    const BookmarkNode* parent = parent_node_->GetChild(position.index);
     *index = parent->GetChildCount();
     return parent;
   }
diff --git a/chrome/browser/views/bookmark_table_view.h b/chrome/browser/views/bookmark_table_view.h
index b80d1fa..2cd6891 100644
--- a/chrome/browser/views/bookmark_table_view.h
+++ b/chrome/browser/views/bookmark_table_view.h
@@ -35,7 +35,7 @@ class BookmarkTableView : public views::TableView {
 
   // Sets the parent of the nodes being displayed. For search and recently
   // found results |parent| is NULL.
-  void set_parent_node(BookmarkNode* parent) { parent_node_ = parent; }
+  void set_parent_node(const BookmarkNode* parent) { parent_node_ = parent; }
 
   // Sets whether the path column should be shown. The path column is shown
   // for search results and recently bookmarked.
@@ -127,8 +127,8 @@ class BookmarkTableView : public views::TableView {
   DropPosition CalculateDropPosition(int y);
 
   // Returns the BookmarkNode the drop should occur on.
-  BookmarkNode* GetDropParentAndIndex(const DropPosition& position,
-                                      int* index);
+  const BookmarkNode* GetDropParentAndIndex(const DropPosition& position,
+                                            int* index);
 
   // Returns the bounds of drop indicator shown when the drop is to occur
   // between rows (drop_on is false).
@@ -149,7 +149,7 @@ class BookmarkTableView : public views::TableView {
 
   Profile* profile_;
 
-  BookmarkNode* parent_node_;
+  const BookmarkNode* parent_node_;
 
   scoped_ptr<DropInfo> drop_info_;
 
diff --git a/chrome/browser/views/toolbar_view.cc b/chrome/browser/views/toolbar_view.cc
index 83c9107..430da1c 100644
--- a/chrome/browser/views/toolbar_view.cc
+++ b/chrome/browser/views/toolbar_view.cc
@@ -757,7 +757,7 @@ void ToolbarView::WriteDragData(views::View* sender,
   TabContents* tab = browser_->GetSelectedTabContents();
   if (tab) {
     if (profile_ && profile_->GetBookmarkModel()) {
-      BookmarkNode* node = profile_->GetBookmarkModel()->
+      const BookmarkNode* node = profile_->GetBookmarkModel()->
           GetMostRecentlyAddedNodeForURL(tab->GetURL());
       if (node) {
         BookmarkDragData bookmark_data(node);
diff --git a/chrome/test/testing_profile.cc b/chrome/test/testing_profile.cc
index 2ea7c51..4e3d1d7 100644
--- a/chrome/test/testing_profile.cc
+++ b/chrome/test/testing_profile.cc
@@ -44,22 +44,22 @@ class BookmarkLoadObserver : public BookmarkModelObserver {
   }
 
   virtual void BookmarkNodeMoved(BookmarkModel* model,
-                                 BookmarkNode* old_parent,
+                                 const BookmarkNode* old_parent,
                                  int old_index,
-                                 BookmarkNode* new_parent,
+                                 const BookmarkNode* new_parent,
                                  int new_index) {}
   virtual void BookmarkNodeAdded(BookmarkModel* model,
-                                 BookmarkNode* parent,
+                                 const BookmarkNode* parent,
                                  int index) {}
   virtual void BookmarkNodeRemoved(BookmarkModel* model,
-                                   BookmarkNode* parent,
+                                   const BookmarkNode* parent,
                                    int index) {}
   virtual void BookmarkNodeChanged(BookmarkModel* model,
-                                   BookmarkNode* node) {}
+                                   const BookmarkNode* node) {}
   virtual void BookmarkNodeChildrenReordered(BookmarkModel* model,
-                                             BookmarkNode* node) {}
+                                             const BookmarkNode* node) {}
   virtual void BookmarkNodeFavIconLoaded(BookmarkModel* model,
-                                         BookmarkNode* node) {}
+                                         const BookmarkNode* node) {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BookmarkLoadObserver);