Limit access to ChromeBookmarkClient to bookmarks code

components/bookmarks/browser/bookmark_utils.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/browser/bookmark_utils.h"
 
 #include <utility>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 295 matching lines @@
     MakeTitleUnique(model,
                     parent,
                     bookmark_data.elements[0].url,
                     &bookmark_data.elements[0].title);
   }
 
   CloneBookmarkNode(model, bookmark_data.elements, parent, index, true);
 }
 
 bool CanPasteFromClipboard(BookmarkModel* model, const BookmarkNode* node) {
-  if (!node || !model->client()->CanBeEditedByUser(node))
+  if (!node || !model->CanBeEditedByUser(node))
     return false;
   return (BookmarkNodeData::ClipboardContainsBookmarks() ||
           GetUrlFromClipboard().is_valid());
 }
 
 std::vector<const BookmarkNode*> GetMostRecentlyModifiedUserFolders(
     BookmarkModel* model,
     size_t max_count) {
   std::vector<const BookmarkNode*> nodes;
   ui::TreeNodeIterator<const BookmarkNode> iterator(
       model->root_node(), base::Bind(&PruneInvisibleFolders));
 
   while (iterator.has_next()) {
     const BookmarkNode* parent = iterator.Next();
-    if (!model->client()->CanBeEditedByUser(parent))
+    if (!model->CanBeEditedByUser(parent))
       continue;
     if (parent->is_folder() && parent->date_folder_modified() > Time()) {
       if (max_count == 0) {
         nodes.push_back(parent);
       } else {
         std::vector<const BookmarkNode*>::iterator i =
             std::upper_bound(nodes.begin(), nodes.end(), parent,
                              &MoreRecentlyModified);
         if (nodes.size() < max_count || i != nodes.end()) {
           nodes.insert(i, parent);
           while (nodes.size() > max_count)
             nodes.pop_back();
         }
       }
     }  // else case, the root node, which we don't care about or imported nodes
        // (which have a time of 0).
   }
 
   if (nodes.size() < max_count) {
     // Add the permanent nodes if there is space. The permanent nodes are the
     // only children of the root_node.
     const BookmarkNode* root_node = model->root_node();
 
     for (int i = 0; i < root_node->child_count(); ++i) {
       const BookmarkNode* node = root_node->GetChild(i);
-      if (node->IsVisible() && model->client()->CanBeEditedByUser(node) &&
+      if (node->IsVisible() && model->CanBeEditedByUser(node) &&
           std::find(nodes.begin(), nodes.end(), node) == nodes.end()) {
         nodes.push_back(node);
 
         if (nodes.size() == max_count)
           break;
       }
     }
   }
   return nodes;
 }
@@ skipping 106 matching lines @@
       continue;
     model->Remove(node);
   }
 }
 
 void AddIfNotBookmarked(BookmarkModel* model,
                         const GURL& url,
                         const base::string16& title) {
   if (IsBookmarkedByUser(model, url))
     return;  // Nothing to do, a user bookmark with that url already exists.
-  model->client()->RecordAction(base::UserMetricsAction("BookmarkAdded"));
+  model->RecordAction(base::UserMetricsAction("BookmarkAdded"));
   const BookmarkNode* parent = model->GetParentForNewNodes();
   model->AddURL(parent, parent->child_count(), title, url);
 }
 
 void RemoveAllBookmarks(BookmarkModel* model, const GURL& url) {
   std::vector<const BookmarkNode*> bookmarks;
   model->GetNodesByURL(url, &bookmarks);
 
   // Remove all the user bookmarks.
   for (size_t i = 0; i < bookmarks.size(); ++i) {
     const BookmarkNode* node = bookmarks[i];
     int index = node->parent()->GetIndexOf(node);
-    if (index > -1 && model->client()->CanBeEditedByUser(node))
+    if (index > -1 && model->CanBeEditedByUser(node))
       model->Remove(node);
   }
 }
 
 base::string16 CleanUpUrlForMatching(
     const GURL& gurl,
     const std::string& languages,
     base::OffsetAdjuster::Adjustments* adjustments) {
   base::OffsetAdjuster::Adjustments tmp_adjustments;
   return base::i18n::ToLower(net::FormatUrlWithAdjustments(
       GURL(TruncateUrl(gurl.spec())), languages,
       net::kFormatUrlOmitUsernamePassword,
       net::UnescapeRule::SPACES | net::UnescapeRule::URL_SPECIAL_CHARS,
       NULL, NULL, adjustments ? adjustments : &tmp_adjustments));
 }
 
 base::string16 CleanUpTitleForMatching(const base::string16& title) {
   return base::i18n::ToLower(title.substr(0u, kCleanedUpTitleMaxLength));
 }
 
-bool CanAllBeEditedByUser(BookmarkClient* client,
+bool CanAllBeEditedByUser(BookmarkModel* model,
                           const std::vector<const BookmarkNode*>& nodes) {
   for (size_t i = 0; i < nodes.size(); ++i) {
-    if (!client->CanBeEditedByUser(nodes[i]))
+    if (!model->CanBeEditedByUser(nodes[i]))
       return false;
   }
   return true;
 }
 
 bool IsBookmarkedByUser(BookmarkModel* model, const GURL& url) {
   std::vector<const BookmarkNode*> nodes;
   model->GetNodesByURL(url, &nodes);
   for (size_t i = 0; i < nodes.size(); ++i) {
-    if (model->client()->CanBeEditedByUser(nodes[i]))
+    if (model->CanBeEditedByUser(nodes[i]))
       return true;
   }
   return false;
 }
 
 const BookmarkNode* GetBookmarkNodeByID(const BookmarkModel* model, int64 id) {
   // TODO(sky): TreeNode needs a method that visits all nodes using a predicate.
   return GetNodeByID(model->root_node(), id);
 }
 
 bool IsDescendantOf(const BookmarkNode* node, const BookmarkNode* root) {
   return node && node->HasAncestor(root);
 }
 
 bool HasDescendantsOf(const std::vector<const BookmarkNode*>& list,
                       const BookmarkNode* root) {
   for (const BookmarkNode* node : list) {
     if (IsDescendantOf(node, root))
       return true;
   }
   return false;
 }
 
 }  // namespace bookmarks