Allow embedder to force visibility of permanent nodes

components/bookmarks/core/browser/bookmark_model.cc

 // Copyright 2014 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 "components/bookmarks/core/browser/bookmark_model.h"
 
 #include <algorithm>
 #include <functional>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/i18n/string_compare.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/strings/string_util.h"
 #include "components/bookmarks/core/browser/bookmark_expanded_state_tracker.h"
 #include "components/bookmarks/core/browser/bookmark_index.h"
 #include "components/bookmarks/core/browser/bookmark_match.h"
 #include "components/bookmarks/core/browser/bookmark_model_observer.h"
 #include "components/bookmarks/core/browser/bookmark_node_data.h"
 #include "components/bookmarks/core/browser/bookmark_storage.h"
 #include "components/bookmarks/core/browser/bookmark_utils.h"
 #include "components/favicon_base/favicon_types.h"
 #include "grit/component_strings.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/favicon_size.h"
 
 using base::Time;
 
 namespace {
 
 // Helper to get a mutable bookmark node.
 BookmarkNode* AsMutable(const BookmarkNode* node) {
   return const_cast<BookmarkNode*>(node);
 }
 
+// Helper to get a mutable permanent bookmark node.
+BookmarkPermanentNode* AsMutable(const BookmarkPermanentNode* node) {
+  return const_cast<BookmarkPermanentNode*>(node);
+}
+
+// Comparator used when sorting permanent nodes. Nodes that are initially
+// visible are sorted before nodes that are initially hidden.
+class VisibilityComparator
+    : public std::binary_function<const BookmarkPermanentNode*,
+                                  const BookmarkPermanentNode*,
+                                  bool> {
+ public:
+  explicit VisibilityComparator(BookmarkClient* client) : client_(client) {}
+
+  // Returns true if |n1| preceeds |n2|.
+  bool operator()(const BookmarkPermanentNode* n1,
+                  const BookmarkPermanentNode* n2) {
+    bool n1_visible = client_->IsPermanentNodeVisible(n1->type());
+    bool n2_visible = client_->IsPermanentNodeVisible(n2->type());
+    return n1_visible != n2_visible && n1_visible;
+  }
+
+ private:
+  BookmarkClient* client_;
+};
+
 // Comparator used when sorting bookmarks. Folders are sorted first, then
 // bookmarks.
 class SortComparator : public std::binary_function<const BookmarkNode*,
                                                    const BookmarkNode*,
                                                    bool> {
  public:
   explicit SortComparator(icu::Collator* collator) : collator_(collator) {}
 
   // Returns true if |n1| preceeds |n2|.
   bool operator()(const BookmarkNode* n1, const BookmarkNode* n2) {
@@ skipping 605 matching lines @@
 
   index_->GetBookmarksMatching(text, max_count, matches);
 }
 
 void BookmarkModel::ClearStore() {
   store_ = NULL;
 }
 
 void BookmarkModel::SetPermanentNodeVisible(BookmarkNode::Type type,
                                             bool value) {
+  AsMutable(PermanentNode(type))->set_visible(
+      value || client_->IsPermanentNodeVisible(type));
+}
+
+const BookmarkPermanentNode* BookmarkModel::PermanentNode(
+    BookmarkNode::Type type) {
   DCHECK(loaded_);
   switch (type) {
     case BookmarkNode::BOOKMARK_BAR:
-      bookmark_bar_node_->set_visible(value);
-      break;
+      return bookmark_bar_node_;
     case BookmarkNode::OTHER_NODE:
-      other_node_->set_visible(value);
-      break;
+      return other_node_;
     case BookmarkNode::MOBILE:
-      mobile_node_->set_visible(value);
-      break;
+      return mobile_node_;
     default:
       NOTREACHED();
+      return NULL;
   }
 }
 
 bool BookmarkModel::IsBookmarkedNoLock(const GURL& url) {
   BookmarkNode tmp_node(url);
   return (nodes_ordered_by_url_set_.find(&tmp_node) !=
           nodes_ordered_by_url_set_.end());
 }
 
 void BookmarkModel::RemoveNode(BookmarkNode* node,
@@ skipping 34 matching lines @@
     // 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();
   mobile_node_ = details->release_mobile_folder_node();
   index_.reset(details->release_index());
 
   // 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(mobile_node_, 2);
+  // constant (but can vary between embedders with the initial visibility
+  // of permanent nodes).
+  BookmarkPermanentNode* root_children[] = {
+      bookmark_bar_node_, other_node_, mobile_node_,
+  };
+  std::stable_sort(root_children,
+                   root_children + arraysize(root_children),
+                   VisibilityComparator(client_));
+  for (size_t i = 0; i < arraysize(root_children); ++i) {
+    root_.Add(root_children[i], static_cast<int>(i));
+  }
 
   root_.SetMetaInfoMap(details->model_meta_info_map());
   root_.set_sync_transaction_version(details->model_sync_transaction_version());
 
   {
     base::AutoLock url_lock(url_lock_);
     // Update nodes_ordered_by_url_set_ from the nodes.
     PopulateNodesByURL(&root_);
   }
 
@@ skipping 93 matching lines @@
                           (allow_end && index == parent->child_count()))));
 }
 
 BookmarkPermanentNode* BookmarkModel::CreatePermanentNode(
     BookmarkNode::Type type) {
   DCHECK(type == BookmarkNode::BOOKMARK_BAR ||
          type == BookmarkNode::OTHER_NODE ||
          type == BookmarkNode::MOBILE);
   BookmarkPermanentNode* node =
       new BookmarkPermanentNode(generate_next_node_id());
-  if (type == BookmarkNode::MOBILE)
-    node->set_visible(false);  // Mobile node is initially hidden.
+  node->set_visible(client_->IsPermanentNodeVisible(type));
 
   int title_id;
   switch (type) {
     case BookmarkNode::BOOKMARK_BAR:
       title_id = IDS_BOOKMARK_BAR_FOLDER_NAME;
       break;
     case BookmarkNode::OTHER_NODE:
       title_id = IDS_BOOKMARK_BAR_OTHER_FOLDER_NAME;
       break;
     case BookmarkNode::MOBILE:
@@ skipping 83 matching lines @@
       CreatePermanentNode(BookmarkNode::OTHER_NODE);
   BookmarkPermanentNode* mobile_node =
       CreatePermanentNode(BookmarkNode::MOBILE);
   return scoped_ptr<BookmarkLoadDetails>(new BookmarkLoadDetails(
       bb_node,
       other_node,
       mobile_node,
       new BookmarkIndex(client_, index_urls_, accept_languages),
       next_node_id_));
 }