Added BookmarkClient::CanBeEditedByUser.

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/files/file_path.h"
 #include "base/i18n/case_conversion.h"
 #include "base/i18n/string_search.h"
 #include "base/metrics/user_metrics_action.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
+#include "components/bookmarks/browser/bookmark_client.h"
 #include "components/bookmarks/browser/bookmark_model.h"
 #include "components/bookmarks/browser/scoped_group_bookmark_actions.h"
 #include "components/bookmarks/common/bookmark_pref_names.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/query_parser/query_parser.h"
 #include "net/base/net_util.h"
 #include "ui/base/models/tree_node_iterator.h"
 #include "url/gurl.h"
 
 using base::Time;
@@ skipping 169 matching lines @@
   BookmarkNodeData bookmark_data;
   if (!bookmark_data.ReadFromClipboard(ui::CLIPBOARD_TYPE_COPY_PASTE))
     return;
 
   if (index == -1)
     index = parent->child_count();
   bookmarks::ScopedGroupBookmarkActions group_paste(model);
   CloneBookmarkNode(model, bookmark_data.elements, parent, index, true);
 }
 
-bool CanPasteFromClipboard(const BookmarkNode* node) {
-  if (!node)
+bool CanPasteFromClipboard(BookmarkModel* model, const BookmarkNode* node) {
+  if (!node || !model->client()->CanBeEditedByUser(node))
     return false;
   return BookmarkNodeData::ClipboardContainsBookmarks();
 }
 
-std::vector<const BookmarkNode*> GetMostRecentlyModifiedFolders(
+std::vector<const BookmarkNode*> GetMostRecentlyModifiedUserFolders(
     BookmarkModel* model,
     size_t max_count) {
   std::vector<const BookmarkNode*> nodes;
   ui::TreeNodeIterator<const BookmarkNode> iterator(model->root_node(),
                                                     PruneInvisibleFolders);
 
   while (iterator.has_next()) {
     const BookmarkNode* parent = iterator.Next();
+    if (!model->client()->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() &&
+      if (node->IsVisible() && model->client()->CanBeEditedByUser(node) &&
           std::find(nodes.begin(), nodes.end(), node) == nodes.end()) {
         nodes.push_back(node);
 
         if (nodes.size() == max_count)
           break;
       }
     }
   }
   return nodes;
 }
@@ skipping 113 matching lines @@
     if (!node)
       continue;
     const BookmarkNode* parent = node->parent();
     model->Remove(parent, parent->GetIndexOf(node));
   }
 }
 
 void AddIfNotBookmarked(BookmarkModel* model,
                         const GURL& url,
                         const base::string16& title) {
-  std::vector<const BookmarkNode*> bookmarks;
-  model->GetNodesByURL(url, &bookmarks);
-  if (!bookmarks.empty())
-    return;  // Nothing to do, a bookmark with that url already exists.
-
+  if (IsBookmarkedByUser(model, url))
+    return;  // Nothing to do, a user bookmark with that url already exists.
   model->client()->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 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)
+    if (index > -1 && model->client()->CanBeEditedByUser(node))
       model->Remove(node->parent(), index);
   }
 }
 
 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,
+                          const std::vector<const BookmarkNode*>& list) {
+  for (size_t i = 0; i < list.size(); ++i) {
+    if (!client->CanBeEditedByUser(list[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]))
+      return true;
+  }
+  return false;
+}
+
 }  // namespace bookmark_utils
 
 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);
 }