Revert "Revert 84829 - Initial implementation of "Synced Bookmarks" folder."

chrome/browser/bookmarks/bookmark_model.h

 // 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.
 
 #ifndef CHROME_BROWSER_BOOKMARKS_BOOKMARK_MODEL_H_
 #define CHROME_BROWSER_BOOKMARKS_BOOKMARK_MODEL_H_
 #pragma once
 
 #include "build/build_config.h"
 
@@ skipping 32 matching lines @@
 // star id and type. BookmarkNodes are returned from a BookmarkModel.
 //
 class BookmarkNode : public ui::TreeNode<BookmarkNode> {
   friend class BookmarkModel;
 
  public:
   enum Type {
     URL,
     FOLDER,
     BOOKMARK_BAR,
-    OTHER_NODE
+    OTHER_NODE,
+    SYNCED
   };
   // 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(int64 id, const GURL& url);
   virtual ~BookmarkNode();
 
   // Returns the URL.
   const GURL& GetURL() const { return url_; }
   // Sets the URL to the given value.
@@ skipping 38 matching lines @@
   // this does not.
   const SkBitmap& favicon() const { return favicon_; }
   void set_favicon(const SkBitmap& icon) { favicon_ = icon; }
 
   // The following methods are used by the bookmark model, and are not
   // really useful outside of it.
 
   bool is_favicon_loaded() const { return loaded_favicon_; }
   void set_favicon_loaded(bool value) { loaded_favicon_ = value; }
 
+  // Accessor method for controlling the visibility of a bookmark node/sub-tree.
+  // Note that visibility is not propagated down the tree hierarchy so if a
+  // parent node is marked as invisible, a child node may return "Visible". This
+  // function is primarily useful when traversing the model to generate a UI
+  // representation but we may want to suppress some nodes.
+  // TODO(yfriedman): Remove this when enable-synced-bookmarks-folder is
+  // no longer a command line flag.
+  bool IsVisible() const;
+
   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();
 
@@ skipping 64 matching lines @@
   // Returns the root node. The bookmark bar node and other node are children of
   // the root node.
   const BookmarkNode* root_node() { return &root_; }
 
   // Returns the bookmark bar node. This is NULL until loaded.
   const BookmarkNode* GetBookmarkBarNode() { return bookmark_bar_node_; }
 
   // Returns the 'other' node. This is NULL until loaded.
   const BookmarkNode* other_node() { return other_node_; }
 
+  // Returns the 'synced' node. This is NULL until loaded.
+  const BookmarkNode* synced_node() { return synced_node_; }
+
   // Returns the parent the last node was added to. This never returns NULL
   // (as long as the model is loaded).
   const BookmarkNode* GetParentForNewNodes();
 
   void AddObserver(BookmarkModelObserver* observer) {
     observers_.AddObserver(observer);
   }
 
   void RemoveObserver(BookmarkModelObserver* observer) {
     observers_.RemoveObserver(observer);
@@ skipping 98 matching lines @@
       const string16& text,
       size_t max_count,
       std::vector<bookmark_utils::TitleMatch>* matches);
 
   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_synced_bookmarks_node(const BookmarkNode* node) const {
+    return node == synced_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);
+           is_other_bookmarks_node(node) ||
+           is_synced_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.
   void ClearStore();
 
   // Returns whether the bookmarks file changed externally.
   bool file_changed() const { return file_changed_; }
 
@@ skipping 40 matching lines @@
                         int index,
                         BookmarkNode* node,
                         bool was_bookmarked);
 
   // Implementation of GetNodeByID.
   const BookmarkNode* GetNodeByID(const BookmarkNode* node, int64 id);
 
   // Returns true if the parent and index are valid.
   bool IsValidIndex(const BookmarkNode* parent, int index, bool allow_end);
 
-  // Creates the bookmark bar/other nodes. These call into
+  // Creates the bookmark bar/synced/other nodes. These call into
   // CreateRootNodeFromStarredEntry.
   BookmarkNode* CreateBookmarkNode();
   BookmarkNode* CreateOtherBookmarksNode();
+  BookmarkNode* CreateSyncedBookmarksNode();
 
   // Creates a root node (either the bookmark bar node or other node) from the
   // specified starred entry.
   BookmarkNode* CreateRootNodeFromStarredEntry(
       const history::StarredEntry& entry);
 
   // Notification that a favicon has finished loading. If we can decode the
   // favicon, FaviconLoaded is invoked.
   void OnFaviconDataAvailable(FaviconService::Handle handle,
                               history::FaviconData favicon);
@@ skipping 35 matching lines @@
   // Whether the bookmarks file was changed externally. This is set after
   // loading is complete and once set the value never changes.
   bool file_changed_;
 
   // The root node. This contains the bookmark bar node and the 'other' node as
   // children.
   BookmarkNode root_;
 
   BookmarkNode* bookmark_bar_node_;
   BookmarkNode* other_node_;
+  BookmarkNode* synced_node_;
 
   // The maximum ID assigned to the bookmark nodes in the model.
   int64 next_node_id_;
 
   // The observers.
   ObserverList<BookmarkModelObserver> observers_;
 
   // Set of nodes ordered by URL. This is not a map to avoid copying the
   // urls.
   // WARNING: nodes_ordered_by_url_set_ is accessed on multiple threads. As
   // such, be sure and wrap all usage of it around url_lock_.
   typedef std::multiset<BookmarkNode*, NodeURLComparator> NodesOrderedByURLSet;
   NodesOrderedByURLSet nodes_ordered_by_url_set_;
   base::Lock url_lock_;
 
   // Used for loading favicons and the empty history request.
   CancelableRequestConsumerTSimple<BookmarkNode*> load_consumer_;
 
   // Reads/writes bookmarks to disk.
   scoped_refptr<BookmarkStorage> store_;
 
   scoped_ptr<BookmarkIndex> index_;
 
   base::WaitableEvent loaded_signal_;
 
   DISALLOW_COPY_AND_ASSIGN(BookmarkModel);
 };
 
 #endif  // CHROME_BROWSER_BOOKMARKS_BOOKMARK_MODEL_H_