Limit access to ChromeBookmarkClient to bookmarks code

components/bookmarks/browser/bookmark_model.h

 // 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.
 
 #ifndef COMPONENTS_BOOKMARKS_BROWSER_BOOKMARK_MODEL_H_
 #define COMPONENTS_BOOKMARKS_BROWSER_BOOKMARK_MODEL_H_
 
 #include <map>
 #include <set>
 #include <vector>
@@ skipping 72 matching lines @@
             const scoped_refptr<base::SequencedTaskRunner>& io_task_runner,
             const scoped_refptr<base::SequencedTaskRunner>& ui_task_runner);
 
   // Returns true if the model finished loading.
   bool loaded() const { return loaded_; }
 
   // Returns the root node. The 'bookmark bar' node and 'other' node are
   // children of the root node.
   const BookmarkNode* root_node() const { return &root_; }
 
-  // Returns the 'bookmark bar' node. This is NULL until loaded.
+  // Returns the 'bookmark bar' node. This is null until loaded.
   const BookmarkNode* bookmark_bar_node() const { return bookmark_bar_node_; }
 
-  // Returns the 'other' node. This is NULL until loaded.
+  // Returns the 'other' node. This is null until loaded.
   const BookmarkNode* other_node() const { return other_node_; }
 
-  // Returns the 'mobile' node. This is NULL until loaded.
+  // Returns the 'mobile' node. This is null until loaded.
   const BookmarkNode* mobile_node() const { return mobile_node_; }
 
+  // The top-level managed bookmarks foled defined by an enterprise policy. This

[sky, 2015/06/23 22:03:53]

I don't think these should be here. These are loaded externally and not part of
the core bookmarkmodel.

[sdefresne, 2015/06/23 22:13:05]

Were would you recommend putting them? Should I create a new
ManagedBookmarkModel with just those two and put it into
//components/bookmarks/manager/? I cannot leave them in ChromeBookmarkClient
(without causing code duplication) since the client will not be shared between
//ios/chrome/browser and //chrome/browser.

With my patches they are still created and managed by the embedder through the
client (this is the purpose of the |callback| parameter to
HistoryClient::GetLoadExtraNodesCallback => allow the client to set
|managed_node_| and |supervised_node_|), but accessor are provided through the
BookmarkModel for convenience.

+  // is null until loaded.
+  const BookmarkNode* managed_node() const { return managed_node_; }
+
+  // The top-level supervised bookmarks folder, defined by the custodian of a
+  // supervised user. This is null until loaded.
+  const BookmarkNode* supervised_node() const { return supervised_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 'mobile' node, or one of the root
   // nodes supplied by the |client_|.
   bool is_permanent_node(const BookmarkNode* node) const {
     return node && (node == &root_ || node->parent() == &root_);
   }
 
   // Returns the parent the last node was added to. This never returns NULL
@@ skipping 181 matching lines @@
   }
 
   // Sets the sync transaction version of |node|.
   void SetNodeSyncTransactionVersion(const BookmarkNode* node,
                                      int64 sync_transaction_version);
 
   // Notify BookmarkModel that the favicons for |urls| have changed and have to
   // be refetched. This notification is sent by BookmarkClient.
   void OnFaviconChanged(const std::set<GURL>& urls);
 
-  // Returns the client used by this BookmarkModel.
-  BookmarkClient* client() const { return client_; }
+  // Returns true if |node| should sync.

[sky, 2015/06/23 22:03:53]

Same comment for all of these. They are policy decisions and not part of the
core model.

+  bool CanSyncNode(const BookmarkNode* node);
+
+  // Returns true if this node can be edited by the user.
+  // TODO(joaodasilva): the model should check this more aggressively, and
+  // should give the client a means to temporarily disable those checks.
+  // http://crbug.com/49598
+  bool CanBeEditedByUser(const BookmarkNode* node);
+
+  // Returns true if the permanent node |node| should always be visible.
+  bool IsPermanentNodeVisible(const BookmarkPermanentNode* node);
+
+  // Forward the |action| to |client_| to record it. See
+  // BookmarkClient::RecordAction for more information.
+  void RecordAction(const base::UserMetricsAction& action);
 
  private:
   friend class BookmarkCodecTest;
   friend class BookmarkStorage;
   friend class ScopedGroupBookmarkActions;
   friend class TestBookmarkClient;
 
   // Used to order BookmarkNodes by URL.
   class NodeURLComparator {
    public:
@@ skipping 77 matching lines @@
   // Sets the maximum node ID to the given value.
   // This is used by BookmarkCodec to report the maximum ID after it's done
   // decoding since during decoding codec assigns node IDs.
   void set_next_node_id(int64 id) { next_node_id_ = id; }
 
   // Creates and returns a new BookmarkLoadDetails. It's up to the caller to
   // delete the returned object.
   scoped_ptr<BookmarkLoadDetails> CreateLoadDetails(
       const std::string& accept_languages);
 
+  // Called upon completion of extra nodes initialization.
+  void OnExtraNodeLoaded(BookmarkPermanentNode* managed_node,
+                         BookmarkPermanentNode* supervised_node);
+
+  // Returns whether the permanent node is a top-level permanent node.
+  bool IsTopLevelPermanentNode(const BookmarkPermanentNode* node);
+
+  // Returns true if the permanent node can have its title updated.
+  bool CanSetPermanentNodeTitle(const BookmarkNode* node);
+
+  // Returns true if touch icons are preferred over favicons.
+  bool PreferTouchIcon();
+
   BookmarkClient* const client_;
 
   // Whether the initial set of data has been loaded.
   bool loaded_;
 
   // The root node. This contains the bookmark bar node, the 'other' node and
   // the mobile node as children.
   BookmarkNode root_;
 
   BookmarkPermanentNode* bookmark_bar_node_;
   BookmarkPermanentNode* other_node_;
   BookmarkPermanentNode* mobile_node_;
+  BookmarkPermanentNode* managed_node_;
+  BookmarkPermanentNode* supervised_node_;
 
   // The maximum ID assigned to the bookmark nodes in the model.
   int64 next_node_id_;
 
   // The observers.
   base::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 18 matching lines @@
   scoped_ptr<BookmarkExpandedStateTracker> expanded_state_tracker_;
 
   std::set<std::string> non_cloned_keys_;
 
   DISALLOW_COPY_AND_ASSIGN(BookmarkModel);
 };
 
 }  // namespace bookmarks
 
 #endif  // COMPONENTS_BOOKMARKS_BROWSER_BOOKMARK_MODEL_H_