Show the Managed Bookmarks folder in the views UI.

components/bookmarks/browser/bookmark_model.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_model.h"
 
 #include <algorithm>
 #include <functional>
 
 #include "base/bind.h"
@@ skipping 132 matching lines @@
   expanded_state_tracker_.reset(
       new BookmarkExpandedStateTracker(this, pref_service));
 
   // Load the bookmarks. BookmarkStorage notifies us when done.
   store_ = new BookmarkStorage(this, profile_path, io_task_runner.get());
   store_->LoadBookmarks(CreateLoadDetails(accept_languages), ui_task_runner);
 }
 
 const BookmarkNode* BookmarkModel::GetParentForNewNodes() {
   std::vector<const BookmarkNode*> nodes =
-      bookmark_utils::GetMostRecentlyModifiedFolders(this, 1);
+      bookmark_utils::GetMostRecentlyModifiedUserFolders(this, 1);
   DCHECK(!nodes.empty());  // This list is always padded with default folders.
   return nodes[0];
 }
 
 void BookmarkModel::AddObserver(BookmarkModelObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void BookmarkModel::RemoveObserver(BookmarkModelObserver* observer) {
   observers_.RemoveObserver(observer);
@@ skipping 332 matching lines @@
                                   std::vector<const BookmarkNode*>* nodes) {
   base::AutoLock url_lock(url_lock_);
   BookmarkNode tmp_node(url);
   NodesOrderedByURLSet::iterator i = nodes_ordered_by_url_set_.find(&tmp_node);
   while (i != nodes_ordered_by_url_set_.end() && (*i)->url() == url) {
     nodes->push_back(*i);
     ++i;
   }
 }
 
-const BookmarkNode* BookmarkModel::GetMostRecentlyAddedNodeForURL(
+const BookmarkNode* BookmarkModel::GetMostRecentlyAddedUserNodeForURL(
     const GURL& url) {
   std::vector<const BookmarkNode*> nodes;
   GetNodesByURL(url, &nodes);
-  if (nodes.empty())
-    return NULL;
+  std::sort(nodes.begin(), nodes.end(), &bookmark_utils::MoreRecentlyAdded);
 
-  std::sort(nodes.begin(), nodes.end(), &bookmark_utils::MoreRecentlyAdded);
-  return nodes.front();
+  // Look for the first node that the user can edit.
+  for (size_t i = 0; i < nodes.size(); ++i) {
+    if (client_->CanBeEditedByUser(nodes[i]))

[sky, 2014/06/05 23:46:47]

Add test coverage for this.

[Joao da Silva, 2014/06/06 15:41:03]

Done.

+      return nodes[i];
+  }
+
+  return NULL;
 }
 
 bool BookmarkModel::HasBookmarks() {
   base::AutoLock url_lock(url_lock_);
   return !nodes_ordered_by_url_set_.empty();
 }
 
 bool BookmarkModel::IsBookmarked(const GURL& url) {
   base::AutoLock url_lock(url_lock_);
-  return IsBookmarkedNoLock(url);
+  return IsBookmarkedNoLock(url, false);
+}
+
+bool BookmarkModel::IsBookmarkedByUser(const GURL& url) {
+  base::AutoLock url_lock(url_lock_);
+  return IsBookmarkedNoLock(url, true);
 }
 
 void BookmarkModel::GetBookmarks(
     std::vector<BookmarkService::URLAndTitle>* bookmarks) {
   base::AutoLock url_lock(url_lock_);
   const GURL* last_url = NULL;
   for (NodesOrderedByURLSet::iterator i = nodes_ordered_by_url_set_.begin();
        i != nodes_ordered_by_url_set_.end(); ++i) {
     const GURL* url = &((*i)->url());
     // Only add unique URLs.
@@ skipping 176 matching lines @@
     case BookmarkNode::OTHER_NODE:
       return other_node_;
     case BookmarkNode::MOBILE:
       return mobile_node_;
     default:
       NOTREACHED();
       return NULL;
   }
 }
 
-bool BookmarkModel::IsBookmarkedNoLock(const GURL& url) {
+bool BookmarkModel::IsBookmarkedNoLock(const GURL& url,
+                                       bool only_by_editable_nodes) {
   BookmarkNode tmp_node(url);
-  return (nodes_ordered_by_url_set_.find(&tmp_node) !=
-          nodes_ordered_by_url_set_.end());
+  typedef NodesOrderedByURLSet::const_iterator Iterator;
+  std::pair<Iterator, Iterator> range =
+      nodes_ordered_by_url_set_.equal_range(&tmp_node);
+  for (Iterator it = range.first; it != range.second; ++it) {
+    if (!only_by_editable_nodes || client_->CanBeEditedByUser(*it))
+      return true;
+  }
+  return false;
 }
 
 void BookmarkModel::RemoveNode(BookmarkNode* node,
                                std::set<GURL>* removed_urls) {
   if (!loaded_ || !node || is_permanent_node(node)) {
     NOTREACHED();
     return;
   }
 
   url_lock_.AssertAcquired();
@@ skipping 114 matching lines @@
   url_lock_.AssertAcquired();
   DCHECK(removed_urls);
   BookmarkNode* parent = AsMutable(node->parent());
   DCHECK(parent);
   parent->Remove(node);
   RemoveNode(node, removed_urls);
   // RemoveNode adds an entry to removed_urls for each node of type URL. As we
   // allow duplicates we need to remove any entries that are still bookmarked.
   for (std::set<GURL>::iterator i = removed_urls->begin();
        i != removed_urls->end();) {
-    if (IsBookmarkedNoLock(*i)) {
+    if (IsBookmarkedNoLock(*i, false)) {
       // When we erase the iterator pointing at the erasee is
       // invalidated, so using i++ here within the "erase" call is
       // important as it advances the iterator before passing the
       // old value through to erase.
       removed_urls->erase(i++);
     } else {
       ++i;
     }
   }
 }
@@ skipping 127 matching lines @@
   BookmarkPermanentNode* mobile_node =
       CreatePermanentNode(BookmarkNode::MOBILE);
   return scoped_ptr<BookmarkLoadDetails>(new BookmarkLoadDetails(
       bb_node,
       other_node,
       mobile_node,
       client_->GetLoadExtraNodesCallback(),
       new BookmarkIndex(client_, index_urls_, accept_languages),
       next_node_id_));
 }