BookmarkModel cleanup. synced_node is now mobile_node and I'm nuking

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 <set>
 #include <vector>
@@ skipping 32 matching lines @@
 
 // BookmarkNode contains information about a starred entry: title, URL, favicon,
 // id and type. BookmarkNodes are returned from BookmarkModel.
 class BookmarkNode : public ui::TreeNode<BookmarkNode> {
  public:
   enum Type {
     URL,
     FOLDER,
     BOOKMARK_BAR,
     OTHER_NODE,
-    SYNCED
+    MOBILE
   };
 
   // Creates a new node with an id of 0 and |url|.
   explicit BookmarkNode(const GURL& url);
   // Creates a new node with |id| and |url|.
   BookmarkNode(int64 id, const GURL& url);
 
   virtual ~BookmarkNode();
 
   // Returns an unique id for this node.
@@ skipping 39 matching lines @@
   bool is_favicon_loaded() const { return is_favicon_loaded_; }
   void set_is_favicon_loaded(bool loaded) { is_favicon_loaded_ = loaded; }
 
   HistoryService::Handle favicon_load_handle() const {
     return favicon_load_handle_;
   }
   void set_favicon_load_handle(HistoryService::Handle handle) {
     favicon_load_handle_ = handle;
   }
 
-  // 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.
-  virtual bool IsVisible() const;
-
   // TODO(sky): Consider adding last visit time here, it'll greatly simplify
   // HistoryContentsProvider.
 
  private:
   friend class BookmarkModel;
 
   // A helper function to initialize various fields during construction.
   void Initialize(int64 id);
 
   // Called when the favicon becomes invalid.
@@ skipping 21 matching lines @@
   // Whether the favicon has been loaded.
   bool is_favicon_loaded_;
 
   // If non-zero, it indicates we're loading the favicon and this is the handle
   // from the HistoryService.
   HistoryService::Handle favicon_load_handle_;
 
   DISALLOW_COPY_AND_ASSIGN(BookmarkNode);
 };
 
-// BookmarkPermanentNode ------------------------------------------------------
-
-// The permanent nodes are the three special top level nodes "bookmark_bar",
-// "synced" and "other". Their visibility is dependent on information from the
-// profile, hence this special subclass to accomodate them.
-class BookmarkPermanentNode : public BookmarkNode {
- public:
-  // Creates a new node with |id| and |url|.
-  BookmarkPermanentNode(int64 id, const GURL& url, Profile* profile);
-
-  virtual ~BookmarkPermanentNode();
-  virtual bool IsVisible() const OVERRIDE;
-
- private:
-  Profile* profile_;
-
-  DISALLOW_COPY_AND_ASSIGN(BookmarkPermanentNode);
-};
-
 // BookmarkModel --------------------------------------------------------------
 
 // BookmarkModel provides a directed acyclic graph of URLs and folders.
 // Three graphs are provided for the three entry points: those on the 'bookmarks
-// bar', those in the 'other bookmarks' folder and those in the 'synced' folder.
+// bar', those in the 'other bookmarks' folder and those in the 'mobile' folder.
 //
 // An observer may be attached to observe relevant events.
 //
 // You should NOT directly create a BookmarkModel, instead go through the
 // Profile.
 class BookmarkModel : public content::NotificationObserver,
                       public BookmarkService {
  public:
   explicit BookmarkModel(Profile* profile);
   virtual ~BookmarkModel();
@@ skipping 14 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* bookmark_bar_node() { 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 'mobile' node. This is NULL until loaded.
+  const BookmarkNode* mobile_node() { return mobile_node_; }
 
   bool is_root_node(const BookmarkNode* node) const { return node == &root_; }
 
   // Returns whether the given |node| is one of the permanent nodes - root node,
-  // 'bookmark bar' node, 'other' node or 'synced' node.
+  // 'bookmark bar' node, 'other' node or 'mobile' node.
   bool is_permanent_node(const BookmarkNode* node) const {
     return node == &root_ ||
            node == bookmark_bar_node_ ||
            node == other_node_ ||
-           node == synced_node_;
+           node == mobile_node_;
   }
 
   Profile* profile() const { return profile_; }
 
   // 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);
   void RemoveObserver(BookmarkModelObserver* observer);
@@ skipping 149 matching lines @@
                         BookmarkNode* node,
                         bool was_bookmarked);
 
   // Implementation of GetNodeByID.
   const BookmarkNode* GetNodeByID(const BookmarkNode* node, int64 id) const;
 
   // Returns true if the parent and index are valid.
   bool IsValidIndex(const BookmarkNode* parent, int index, bool allow_end);
 
   // Creates one of the possible permanent nodes (bookmark bar node, other node
-  // and synced node) from |type|.
+  // and mobile node) from |type|.
   BookmarkNode* CreatePermanentNode(BookmarkNode::Type type);
 
   // Notification that a favicon has finished loading. If we can decode the
   // favicon, FaviconLoaded is invoked.
   void OnFaviconDataAvailable(FaviconService::Handle handle,
                               history::FaviconData favicon);
 
   // Invoked from the node to load the favicon. Requests the favicon from the
   // favicon service.
   void LoadFavicon(BookmarkNode* node);
@@ skipping 31 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_;
+  BookmarkNode* mobile_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
@@ skipping 11 matching lines @@
   scoped_ptr<BookmarkIndex> index_;
 
   base::WaitableEvent loaded_signal_;
 
   scoped_ptr<BookmarkExpandedStateTracker> expanded_state_tracker_;
 
   DISALLOW_COPY_AND_ASSIGN(BookmarkModel);
 };
 
 #endif  // CHROME_BROWSER_BOOKMARKS_BOOKMARK_MODEL_H_