Adds back BookmarkNode::IsVisible. Turns out we want to conditionally

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/bind.h"
@@ skipping 37 matching lines @@
 }
 
 BookmarkNode::BookmarkNode(int64 id, const GURL& url)
     : url_(url) {
   Initialize(id);
 }
 
 BookmarkNode::~BookmarkNode() {
 }
 
+bool BookmarkNode::IsVisible() const {
+  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;
 }
 
-// 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:
   explicit SortComparator(icu::Collator* collator) : collator_(collator) { }
 
   // Returns true if lhs preceeds rhs.
   bool operator() (const BookmarkNode* n1, const BookmarkNode* n2) {
     if (n1->type() == n2->type()) {
       // Types are the same, compare the names.
       if (!collator_)
         return n1->GetTitle() < n2->GetTitle();
       return l10n_util::CompareString16WithCollator(
           collator_, n1->GetTitle(), n2->GetTitle()) == UCOL_LESS;
     }
     // Types differ, sort such that folders come first.
     return n1->is_folder();
   }
 
  private:
   icu::Collator* collator_;
 };
 
+// MobileNode ------------------------------------------------------------------
+
+// The visibility of the mobile node changes based on sync state, requiring a
+// special subclass.
+class MobileNode : public BookmarkNode {
+ public:
+  explicit MobileNode(int64 id);
+  virtual ~MobileNode();
+
+  // BookmarkNode overrides:
+  virtual bool IsVisible() const OVERRIDE;
+
+ private:
+  bool visible_;
+
+  DISALLOW_COPY_AND_ASSIGN(MobileNode);
+};
+
+MobileNode::MobileNode(int64 id)
+    : BookmarkNode(id, GURL()),
+      visible_(false) {
+}
+
+MobileNode::~MobileNode() {
+}
+
+bool MobileNode::IsVisible() const {
+  return visible_ || !empty();
+}
+
 }  // namespace
 
+// BookmarkModel --------------------------------------------------------------
+
 BookmarkModel::BookmarkModel(Profile* profile)
     : profile_(profile),
       loaded_(false),
       file_changed_(false),
       root_(GURL()),
       bookmark_bar_node_(NULL),
       other_node_(NULL),
       mobile_node_(NULL),
       next_node_id_(1),
       observers_(ObserverList<BookmarkModelObserver>::NOTIFY_EXISTING_ONLY),
@@ skipping 584 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::MOBILE);
-  BookmarkNode* node = new BookmarkNode(generate_next_node_id(), GURL());
-  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 {
+  BookmarkNode* node;
+  if (type == BookmarkNode::MOBILE) {
+    node = new MobileNode(generate_next_node_id());
     node->set_title(
         l10n_util::GetStringUTF16(IDS_BOOKMARK_BAR_MOBILE_FOLDER_NAME));
+  } else {
+    node = new BookmarkNode(generate_next_node_id(), GURL());
+    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 {
+      NOTREACHED();
+    }
   }
+  node->set_type(type);
   return node;
 }
 
 void BookmarkModel::OnFaviconDataAvailable(
     FaviconService::Handle handle,
     history::FaviconData favicon) {
   SkBitmap favicon_bitmap;
   BookmarkNode* node =
       load_consumer_.GetClientData(
           profile_->GetFaviconService(Profile::EXPLICIT_ACCESS), handle);
@@ skipping 81 matching lines @@
   return next_node_id_++;
 }
 
 BookmarkLoadDetails* BookmarkModel::CreateLoadDetails() {
   BookmarkNode* bb_node = CreatePermanentNode(BookmarkNode::BOOKMARK_BAR);
   BookmarkNode* other_node = CreatePermanentNode(BookmarkNode::OTHER_NODE);
   BookmarkNode* mobile_node = CreatePermanentNode(BookmarkNode::MOBILE);
   return new BookmarkLoadDetails(bb_node, other_node, mobile_node,
                                  new BookmarkIndex(profile_), next_node_id_);
 }