Permanent folders changes

chrome/browser/bookmarks/bookmark_model.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/bookmarks/bookmark_model.h"
 
 #include <algorithm>
 #include <functional>
 
 #include "base/callback.h"
@@ skipping 38 matching lines @@
 
 BookmarkNode::BookmarkNode(int64 id, const GURL& url)
     : url_(url) {
   Initialize(id);
 }
 
 BookmarkNode::~BookmarkNode() {
 }
 
 bool BookmarkNode::IsVisible() const {
-  // The synced bookmark folder is invisible if the flag isn't set and there are
-  // no bookmarks under it.
-  if (type_ != BookmarkNode::SYNCED ||
-      CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kEnableSyncedBookmarksFolder) || !empty()) {
-    return true;
-  }
-  return false;
+  return true;
 }
 
 void BookmarkNode::Initialize(int64 id) {
   id_ = id;
   type_ = url_.is_empty() ? FOLDER : URL;
   date_added_ = Time::Now();
   is_favicon_loaded_ = false;
   favicon_load_handle_ = 0;
 }
 
 void BookmarkNode::InvalidateFavicon() {
   favicon_ = SkBitmap();
   is_favicon_loaded_ = false;
 }
 
+// BookmarkPermanentNode ------------------------------------------------------
+
+BookmarkPermanentNode::BookmarkPermanentNode(int64 id,
+                                             const GURL& url,
+                                             Profile* profile)
+    : BookmarkNode(id, url),
+      profile_(profile) {
+}
+
+BookmarkPermanentNode::~BookmarkPermanentNode() {
+}
+
+bool BookmarkPermanentNode::IsVisible() const {
+  // The synced bookmark folder is invisible if the flag isn't set and there are
+  // no bookmarks under it.
+  return type() != BookmarkNode::SYNCED ||
+         CommandLine::ForCurrentProcess()->HasSwitch(
+             switches::kEnableSyncedBookmarksFolder) ||
+         !empty();
+}
+
 // BookmarkModel --------------------------------------------------------------
 
 namespace {
 
 // Comparator used when sorting bookmarks. Folders are sorted first, then
 // bookmarks.
 class SortComparator : public std::binary_function<const BookmarkNode*,
                                                    const BookmarkNode*,
                                                    bool> {
  public:
@@ skipping 73 matching lines @@
   store_->LoadBookmarks(CreateLoadDetails());
 }
 
 bool BookmarkModel::IsLoaded() const {
   return loaded_;
 }
 
 const BookmarkNode* BookmarkModel::GetParentForNewNodes() {
   std::vector<const BookmarkNode*> nodes =
       bookmark_utils::GetMostRecentlyModifiedFolders(this, 1);
-  return nodes.empty() ? bookmark_bar_node_ : nodes[0];
+  DCHECK(!nodes.empty());  // This list is always padded with default folders.
+  return nodes[0];
 }
 
 void BookmarkModel::AddObserver(BookmarkModelObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void BookmarkModel::RemoveObserver(BookmarkModelObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
@@ skipping 373 matching lines @@
     // them unique. So when the file has changed externally, we should save the
     // bookmarks file to persist new IDs.
     if (store_.get())
       store_->ScheduleSave();
   }
   bookmark_bar_node_ = details->release_bb_node();
   other_node_ = details->release_other_folder_node();
   synced_node_ = details->release_synced_folder_node();
   index_.reset(details->release_index());
 
-  // WARNING: order is important here, various places assume bookmark bar then
-  // other node.
+  // WARNING: order is important here, various places assume the order is
+  // constant.
   root_.Add(bookmark_bar_node_, 0);
   root_.Add(other_node_, 1);
   root_.Add(synced_node_, 2);
 
   {
     base::AutoLock url_lock(url_lock_);
     // Update nodes_ordered_by_url_set_ from the nodes.
     PopulateNodesByURL(&root_);
   }
 
@@ skipping 107 matching lines @@
                                  bool allow_end) {
   return (parent && parent->is_folder() &&
           (index >= 0 && (index < parent->child_count() ||
                           (allow_end && index == parent->child_count()))));
 }
 
 BookmarkNode* BookmarkModel::CreatePermanentNode(BookmarkNode::Type type) {
   DCHECK(type == BookmarkNode::BOOKMARK_BAR ||
          type == BookmarkNode::OTHER_NODE ||
          type == BookmarkNode::SYNCED);
-  BookmarkNode* node = new BookmarkNode(generate_next_node_id(), GURL());
+  BookmarkPermanentNode* node = new BookmarkPermanentNode(
+      generate_next_node_id(), GURL(), profile_);
   node->set_type(type);
   if (type == BookmarkNode::BOOKMARK_BAR) {
     node->set_title(l10n_util::GetStringUTF16(IDS_BOOKMARK_BAR_FOLDER_NAME));
   } else if (type == BookmarkNode::OTHER_NODE) {
     node->set_title(
         l10n_util::GetStringUTF16(IDS_BOOKMARK_BAR_OTHER_FOLDER_NAME));
   } else {
     node->set_title(
         l10n_util::GetStringUTF16(IDS_BOOKMARK_BAR_SYNCED_FOLDER_NAME));
   }
@@ skipping 94 matching lines @@
   file_changed_ = true;
 }
 
 BookmarkLoadDetails* BookmarkModel::CreateLoadDetails() {
   BookmarkNode* bb_node = CreatePermanentNode(BookmarkNode::BOOKMARK_BAR);
   BookmarkNode* other_node = CreatePermanentNode(BookmarkNode::OTHER_NODE);
   BookmarkNode* synced_node = CreatePermanentNode(BookmarkNode::SYNCED);
   return new BookmarkLoadDetails(bb_node, other_node, synced_node,
                                  new BookmarkIndex(profile_), next_node_id_);
 }