Experimental bookmark model based on tags.

chrome/browser/bookmarks/bookmark_tag_model.cc

+// Copyright 2013 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 "chrome/browser/bookmarks/bookmark_tag_model.h"
+
+#include "base/auto_reset.h"
+#include "base/json/json_string_value_serializer.h"
+#include "base/observer_list.h"
+#include "base/strings/string_util.h"
+#include "base/strings/utf_string_conversions.h"
+#include "chrome/browser/bookmarks/bookmark_model_factory.h"
+#include "chrome/browser/bookmarks/bookmark_tag_model_observer.h"
+#include "ui/base/models/tree_node_iterator.h"
+
+namespace {
+// The key used to store the tag list in the metainfo of a bookmark.
+const char* TAG_KEY = "TAG_KEY";
+
+// Comparator to sort tags by usage.
+struct TagComparator {
+  TagComparator(std::map<BookmarkTag, unsigned int>& tags) : tags_(tags) {
+  }
+  ~TagComparator() {}
+
+  bool operator()(const BookmarkTag& a, const BookmarkTag& b) {
+    return (tags_[a] < tags_[b]);
+  }
+
+  std::map<BookmarkTag, unsigned int>& tags_;
+};
+
+// The tags are currently stored in the BookmarkNode's metaInfo in JSON
+// format. This function extracts the info from there and returns it in
+// digestible format.
+// If the Bookmark was never tagged before it is implicitely tagged with the
+// title of all its ancestors in the BookmarkModel.
+std::set<BookmarkTag> ExtractTagsFromBookmark(const BookmarkNode* bookmark) {
+  // This is awful BTW. Metainfo is itself an encoded JSON, and here we decode
+  // another layer.
+
+  // Retrieve the encodedData from the bookmark. If there is no encoded data
+  // at all returns the name of all the ancestors as separate tags.
+  std::string encoded;
+  if (!bookmark->GetMetaInfo(TAG_KEY, &encoded)) {
+    std::set<BookmarkTag> tags;
+    const BookmarkNode* folder = bookmark->parent();
+    while (folder && folder->type() == BookmarkNode::FOLDER) {
+      BookmarkTag trimmed_tag = CollapseWhitespace(folder->GetTitle(), true);
+      if (!trimmed_tag.empty())
+        tags.insert(trimmed_tag);
+      folder = folder->parent();
+    }
+    return tags;
+  }
+
+  // Decode into a base::Value. If the data is not encoded properly as a list
+  // return an empty result.
+  JSONStringValueSerializer serializer(&encoded);
+  int error_code = 0;
+  std::string error_message;
+  scoped_ptr<base::Value> result(serializer.Deserialize(&error_code,
+                                                        &error_message));
+
+  if (error_code || !result->IsType(base::Value::TYPE_LIST))
+    return std::set<BookmarkTag>();
+
+  base::ListValue* list = NULL;
+  if (!result->GetAsList(&list) || list->empty())
+    return std::set<BookmarkTag>();
+
+  // Build the set.
+  std::set<BookmarkTag> return_value;
+
+  for (base::ListValue::iterator it = list->begin();
+       it != list->end(); ++it) {
+    base::Value* item = *it;
+    BookmarkTag tag;
+    if (!item->GetAsString(&tag))
+      continue;
+    return_value.insert(tag);
+  }
+  return return_value;
+}
+}  // namespace
+
+BookmarkTagModel::BookmarkTagModel(BookmarkModel* bookmark_model)
+    : bookmark_model_(bookmark_model),
+      loaded_(false),
+      observers_(ObserverList<BookmarkTagModelObserver>::NOTIFY_EXISTING_ONLY),
+      inhibit_change_notifications_(false) {
+  bookmark_model_->AddObserver(this);
+  if (bookmark_model_->loaded())
+    Load();
+}
+
+BookmarkTagModel::~BookmarkTagModel() {
+  if (bookmark_model_)
+    bookmark_model_->RemoveObserver(this);
+}
+
+// BookmarkModel forwarding.
+
+void BookmarkTagModel::AddObserver(BookmarkTagModelObserver* observer) {
+  observers_.AddObserver(observer);
+}
+
+void BookmarkTagModel::RemoveObserver(BookmarkTagModelObserver* observer) {
+  observers_.RemoveObserver(observer);
+}
+
+void BookmarkTagModel::BeginExtensiveChanges() {
+  DCHECK(bookmark_model_);
+  bookmark_model_->BeginExtensiveChanges();
+}
+
+void BookmarkTagModel::EndExtensiveChanges() {
+  DCHECK(bookmark_model_);
+  bookmark_model_->EndExtensiveChanges();
+}
+
+bool BookmarkTagModel::IsDoingExtensiveChanges() const {
+  DCHECK(bookmark_model_);
+  return bookmark_model_->IsDoingExtensiveChanges();
+}
+
+void BookmarkTagModel::Remove(const BookmarkNode* bookmark) {
+  DCHECK(bookmark_model_);
+  DCHECK(loaded_);
+  const BookmarkNode* parent = bookmark->parent();
+  bookmark_model_->Remove(parent, parent->GetIndexOf(bookmark));
+}
+
+void BookmarkTagModel::RemoveAll() {
+  DCHECK(bookmark_model_);
+  DCHECK(loaded_);
+  bookmark_model_->RemoveAll();
+}
+
+const gfx::Image& BookmarkTagModel::GetFavicon(const BookmarkNode* bookmark) {
+  DCHECK(bookmark_model_);
+  DCHECK(loaded_);
+  return bookmark_model_->GetFavicon(bookmark);
+}
+
+void BookmarkTagModel::SetTitle(const BookmarkNode* bookmark,
+                                const string16& title) {
+  DCHECK(bookmark_model_);
+  DCHECK(loaded_);
+  bookmark_model_->SetTitle(bookmark, title);
+}
+
+void BookmarkTagModel::SetURL(const BookmarkNode* bookmark, const GURL& url) {
+  DCHECK(bookmark_model_);
+  DCHECK(loaded_);
+  bookmark_model_->SetURL(bookmark, url);
+}
+
+void BookmarkTagModel::SetDateAdded(const BookmarkNode* bookmark,
+                                    base::Time date_added) {
+  DCHECK(bookmark_model_);
+  DCHECK(loaded_);
+  bookmark_model_->SetDateAdded(bookmark, date_added);
+}
+
+const BookmarkNode*
+    BookmarkTagModel::GetMostRecentlyAddedBookmarkForURL(const GURL& url) {
+  DCHECK(bookmark_model_);
+  DCHECK(loaded_);
+  return bookmark_model_->GetMostRecentlyAddedNodeForURL(url);
+}
+
+// Tags specific code.
+
+const BookmarkNode* BookmarkTagModel::AddURL(
+    const string16& title,
+    const GURL& url,
+    const std::set<BookmarkTag>& tags) {
+  DCHECK(bookmark_model_);
+  DCHECK(loaded_);
+
+  const BookmarkNode* bookmark;
+  {
+    base::AutoReset<bool> inhibitor(&inhibit_change_notifications_, true);
+    const BookmarkNode* parent = bookmark_model_->GetParentForNewNodes();
+    bookmark = bookmark_model_->AddURL(parent, 0, title, url);
+    AddTagsToBookmark(tags, bookmark);
+  }
+  FOR_EACH_OBSERVER(BookmarkTagModelObserver, observers_,
+                    BookmarkNodeAdded(this, bookmark));
+
+  return bookmark;
+}
+
+std::set<BookmarkTag> BookmarkTagModel::GetTagsForBookmark(
+    const BookmarkNode* bookmark) {
+  DCHECK(loaded_);
+  return bookmark_to_tags_[bookmark];
+}
+
+void BookmarkTagModel::AddTagsToBookmark(
+    const std::set<BookmarkTag>& tags,
+    const BookmarkNode* bookmark) {
+  DCHECK(bookmark_model_);
+  std::set<BookmarkTag> all_tags(GetTagsForBookmark(bookmark));
+  for (std::set<BookmarkTag>::const_iterator it = tags.begin();
+       it != tags.end(); ++it) {
+    BookmarkTag trimmed_tag = CollapseWhitespace(*it, true);
+    if (trimmed_tag.empty())
+      continue;
+    all_tags.insert(trimmed_tag);
+  }
+  SetTagsOnBookmark(all_tags, bookmark);
+}
+
+void BookmarkTagModel::AddTagsToBookmarks(
+    const std::set<BookmarkTag>& tags,
+    const std::set<const BookmarkNode*>& bookmarks) {
+  for (std::set<const BookmarkNode*>::const_iterator it = bookmarks.begin();
+      it != bookmarks.end(); ++it) {
+    AddTagsToBookmark(tags, *it);
+  }
+}
+
+void BookmarkTagModel::RemoveTagsFromBookmark(
+    const std::set<BookmarkTag>& tags,
+    const BookmarkNode* bookmark) {
+  std::set<BookmarkTag> all_tags(GetTagsForBookmark(bookmark));
+  for (std::set<BookmarkTag>::const_iterator it = tags.begin();
+       it != tags.end(); ++it) {
+    all_tags.erase(*it);
+  }
+  SetTagsOnBookmark(all_tags, bookmark);
+}
+
+void BookmarkTagModel::RemoveTagsFromBookmarks(
+    const std::set<BookmarkTag>& tags,
+    const std::set<const BookmarkNode*>& bookmarks){
+  for (std::set<const BookmarkNode*>::const_iterator it = bookmarks.begin();
+      it != bookmarks.end(); ++it) {
+    RemoveTagsFromBookmark(tags, *it);
+  }
+}
+
+std::set<const BookmarkNode*> BookmarkTagModel::BookmarksForTags(
+    const std::set<BookmarkTag>& tags) {
+  DCHECK(loaded_);
+  // Count for each tags how many times a bookmark appeared.
+  std::map<const BookmarkNode*, size_t> bookmark_counts;
+  for (std::set<BookmarkTag>::const_iterator it = tags.begin();
+       it != tags.end(); ++it) {
+    const std::set<const BookmarkNode*>& subset(tag_to_bookmarks_[*it]);
+    for (std::set<const BookmarkNode*>::const_iterator tag_it = subset.begin();
+         tag_it != subset.end(); ++tag_it) {
+      bookmark_counts[*tag_it] += 1;
+    }
+  }
+  // Keep only the bookmarks that appeared in all the tags.
+  std::set<const BookmarkNode*> common_bookmarks;
+  for (std::map<const BookmarkNode*, size_t>::iterator it =
+      bookmark_counts.begin(); it != bookmark_counts.end(); ++it) {
+    if (it->second == tags.size())
+      common_bookmarks.insert(it->first);
+  }
+  return common_bookmarks;
+}
+
+std::set<const BookmarkNode*> BookmarkTagModel::BookmarksForTag(
+    const BookmarkTag& tag) {
+  DCHECK(!tag.empty());
+  return tag_to_bookmarks_[tag];
+}
+
+std::vector<BookmarkTag> BookmarkTagModel::TagsRelatedToTag(
+    const BookmarkTag& tag) {
+  DCHECK(loaded_);
+  std::map<BookmarkTag, unsigned int> tags;
+
+  if (tag.empty()) {
+    // Returns all the tags.
+    for (std::map<const BookmarkTag, std::set<const BookmarkNode*> >::iterator
+        it = tag_to_bookmarks_.begin(); it != tag_to_bookmarks_.end(); ++it) {
+      tags[it->first] = it->second.size();
+    }
+  } else {
+    std::set<const BookmarkNode*> bookmarks(BookmarksForTag(tag));
+
+    for (std::set<const BookmarkNode*>::iterator it = bookmarks.begin();
+         it != bookmarks.end(); ++it) {
+      const std::set<BookmarkTag>& subset(bookmark_to_tags_[*it]);
+      for (std::set<BookmarkTag>::const_iterator tag_it = subset.begin();
+           tag_it != subset.end(); ++tag_it) {
+        tags[*tag_it] += 1;
+      }
+    }
+    tags.erase(tag);  // A tag is not related to itself.
+  }
+
+  std::vector<BookmarkTag> sorted_tags;
+  for (std::map<BookmarkTag, unsigned int>::iterator it = tags.begin();
+       it != tags.end(); ++it) {
+    sorted_tags.push_back(it->first);
+  }
+  std::sort(sorted_tags.begin(), sorted_tags.end(), TagComparator(tags));
+  return sorted_tags;
+}
+
+// BookmarkModelObserver methods.
+
+void BookmarkTagModel::Loaded(BookmarkModel* model, bool ids_reassigned) {
+  Load();
+}
+
+void BookmarkTagModel::BookmarkModelBeingDeleted(BookmarkModel* model) {
+  DCHECK(bookmark_model_);
+  FOR_EACH_OBSERVER(BookmarkTagModelObserver, observers_,
+                    BookmarkTagModelBeingDeleted(this));
+  bookmark_model_ = NULL;
+}
+
+void BookmarkTagModel::BookmarkNodeMoved(BookmarkModel* model,
+                                         const BookmarkNode* old_parent,
+                                         int old_index,
+                                         const BookmarkNode* new_parent,
+                                         int new_index) {
+  DCHECK(loaded_);
+  const BookmarkNode* bookmark = new_parent->GetChild(new_index);
+  if (bookmark->is_folder()) {
+    ReloadDescendants(bookmark);
+  } else if (bookmark->is_url()) {
+    std::string encoded;
+    if (!bookmark->GetMetaInfo(TAG_KEY, &encoded)) {
+      // The bookmark moved and the system currently use its ancestors name as a
+      // poor approximation for tags.
+      FOR_EACH_OBSERVER(BookmarkTagModelObserver, observers_,
+                        OnWillChangeBookmarkTags(this, bookmark));
+      RemoveBookmark(bookmark);
+      LoadBookmark(bookmark);
+      FOR_EACH_OBSERVER(BookmarkTagModelObserver, observers_,
+                        BookmarkTagsChanged(this, bookmark));
+    }
+  }
+}
+
+void BookmarkTagModel::BookmarkNodeAdded(BookmarkModel* model,
+                                         const BookmarkNode* parent,
+                                         int index) {
+  DCHECK(loaded_);
+  const BookmarkNode* bookmark = parent->GetChild(index);
+  if (!bookmark->is_url())
+    return;
+  LoadBookmark(bookmark);
+
+  if (!inhibit_change_notifications_)
+    FOR_EACH_OBSERVER(BookmarkTagModelObserver, observers_,
+                      BookmarkNodeAdded(this, bookmark));
+}
+
+void BookmarkTagModel::OnWillRemoveBookmarks(BookmarkModel* model,
+                                             const BookmarkNode* parent,
+                                             int old_index,
+                                             const BookmarkNode* node) {
+  DCHECK(loaded_);
+  if (!node->is_url())
+    return;
+  RemoveBookmark(node);
+  FOR_EACH_OBSERVER(BookmarkTagModelObserver, observers_,
+                    OnWillRemoveBookmarks(this, node));
+}
+
+void BookmarkTagModel::BookmarkNodeRemoved(BookmarkModel* model,
+                                           const BookmarkNode* parent,
+                                           int old_index,
+                                           const BookmarkNode* node) {
+  DCHECK(loaded_);
+  if (!node->is_url())
+    return;
+  FOR_EACH_OBSERVER(BookmarkTagModelObserver, observers_,
+                    BookmarkNodeRemoved(this, node));
+}
+
+void BookmarkTagModel::OnWillChangeBookmarkNode(BookmarkModel* model,
+                                                const BookmarkNode* node) {
+  DCHECK(loaded_);
+  if (!node->is_url() || inhibit_change_notifications_)
+    return;
+  FOR_EACH_OBSERVER(BookmarkTagModelObserver, observers_,
+                    OnWillChangeBookmarkNode(this, node));
+}
+
+void BookmarkTagModel::BookmarkNodeChanged(BookmarkModel* model,
+                                           const BookmarkNode* node) {
+  DCHECK(loaded_);
+  if (node->is_folder()) {
+    // A folder title changed. This may change the tags on all the descendants
+    // still using the default tag list of all ancestors.
+    ReloadDescendants(node);
+  } else if (node->is_url()) {
+    if (!inhibit_change_notifications_)
+      FOR_EACH_OBSERVER(BookmarkTagModelObserver, observers_,
+                        BookmarkNodeChanged(this, node));
+  }
+}
+
+void BookmarkTagModel::OnWillChangeBookmarkMetaInfo(BookmarkModel* model,
+                                                    const BookmarkNode* node) {
+  DCHECK(loaded_);
+  if (!node->is_url() || inhibit_change_notifications_)
+    return;
+  FOR_EACH_OBSERVER(BookmarkTagModelObserver, observers_,
+                    OnWillChangeBookmarkTags(this, node));
+}
+
+void BookmarkTagModel::BookmarkMetaInfoChanged(BookmarkModel* model,
+                                               const BookmarkNode* node) {
+  DCHECK(loaded_);
+  if (!node->is_url())
+    return;
+  RemoveBookmark(node);
+  LoadBookmark(node);
+  if (!inhibit_change_notifications_)
+    FOR_EACH_OBSERVER(BookmarkTagModelObserver, observers_,
+                      BookmarkTagsChanged(this, node));
+}
+
+void BookmarkTagModel::BookmarkNodeFaviconChanged(BookmarkModel* model,
+                                                  const BookmarkNode* node) {
+  DCHECK(loaded_);
+  if (!node->is_url())
+    return;
+  FOR_EACH_OBSERVER(BookmarkTagModelObserver, observers_,
+                    BookmarkNodeFaviconChanged(this, node));
+}
+
+void BookmarkTagModel::OnWillReorderBookmarkNode(BookmarkModel* model,
+                                                 const BookmarkNode* node) {
+  // This model doesn't care.
+}
+
+void BookmarkTagModel::BookmarkNodeChildrenReordered(BookmarkModel* model,
+                                                     const BookmarkNode* node) {
+  // This model doesn't care.
+}
+
+void BookmarkTagModel::ExtensiveBookmarkChangesBeginning(BookmarkModel* model) {
+  DCHECK(loaded_);
+  FOR_EACH_OBSERVER(BookmarkTagModelObserver, observers_,
+                    ExtensiveBookmarkChangesBeginning(this));
+}
+
+void BookmarkTagModel::ExtensiveBookmarkChangesEnded(BookmarkModel* model) {
+  DCHECK(loaded_);
+  FOR_EACH_OBSERVER(BookmarkTagModelObserver, observers_,
+                    ExtensiveBookmarkChangesEnded(this));
+}
+
+void BookmarkTagModel::OnWillRemoveAllBookmarks(BookmarkModel* model) {
+  DCHECK(loaded_);
+  FOR_EACH_OBSERVER(BookmarkTagModelObserver, observers_,
+                    OnWillRemoveAllBookmarks(this));
+}
+
+void BookmarkTagModel::BookmarkAllNodesRemoved(BookmarkModel* model){
+  DCHECK(loaded_);
+  tag_to_bookmarks_.clear();
+  bookmark_to_tags_.clear();
+  FOR_EACH_OBSERVER(BookmarkTagModelObserver, observers_,
+                    BookmarkAllNodesRemoved(this));
+}
+
+// Private methods.
+
+void BookmarkTagModel::SetTagsOnBookmark(const std::set<BookmarkTag>& tags,
+                                         const BookmarkNode* bookmark) {
+  DCHECK(bookmark_model_);
+  DCHECK(loaded_);
+
+  // Build a ListValue.
+  std::vector<BookmarkTag> tag_vector(tags.begin(), tags.end());
+  base::ListValue list;
+  list.AppendStrings(tag_vector);
+
+  // Encodes it.
+  std::string encoded;
+  JSONStringValueSerializer serializer(&encoded);
+
+  // Pushes it in the bookmark's metainfo. Even if the tag list is empty the
+  // empty list must be put on the node to avoid reverting to the tag list
+  // derived from the hierarchy.
+  // The internal caches of the BookmarkTagModel are updated when the
+  // notification from the BookmarkModel is received.
+  serializer.Serialize(list);
+  bookmark_model_->SetNodeMetaInfo(bookmark, TAG_KEY, encoded);
+}
+
+void BookmarkTagModel::Load() {
+  DCHECK(bookmark_model_);
+  DCHECK(!loaded_);
+  ui::TreeNodeIterator<const BookmarkNode> iterator(
+      bookmark_model_->root_node());
+  while (iterator.has_next()) {
+    const BookmarkNode* bookmark = iterator.Next();
+    if (bookmark->is_url())
+      LoadBookmark(bookmark);
+  }
+  loaded_ = true;
+  FOR_EACH_OBSERVER(BookmarkTagModelObserver, observers_,
+                    Loaded(this));
+}
+
+void BookmarkTagModel::ReloadDescendants(const BookmarkNode* folder) {
+  DCHECK(folder->is_folder());
+  ExtensiveChanges scoped(ExtensiveChanges(this));
+  ui::TreeNodeIterator<const BookmarkNode> iterator(folder);
+  while (iterator.has_next()) {
+    const BookmarkNode* bookmark = iterator.Next();
+    if (bookmark->is_url()) {
+      FOR_EACH_OBSERVER(BookmarkTagModelObserver, observers_,
+                        OnWillChangeBookmarkTags(this, bookmark));
+      RemoveBookmark(bookmark);
+      LoadBookmark(bookmark);
+      FOR_EACH_OBSERVER(BookmarkTagModelObserver, observers_,
+                        BookmarkTagsChanged(this, bookmark));
+    }
+  }
+}
+
+void BookmarkTagModel::LoadBookmark(const BookmarkNode* bookmark) {
+  DCHECK(bookmark_model_);
+  DCHECK(bookmark->is_url());
+  std::set<BookmarkTag> tags(ExtractTagsFromBookmark(bookmark));
+
+  bookmark_to_tags_[bookmark] = tags;
+  for (std::set<BookmarkTag>::iterator it = tags.begin();
+       it != tags.end(); ++it) {
+    tag_to_bookmarks_[*it].insert(bookmark);
+  }
+}
+
+void BookmarkTagModel::RemoveBookmark(const BookmarkNode* bookmark) {
+  DCHECK(bookmark_model_);
+  DCHECK(bookmark->is_url());
+  std::set<BookmarkTag> tags(bookmark_to_tags_[bookmark]);
+  bookmark_to_tags_.erase(bookmark);
+
+  for (std::set<BookmarkTag>::iterator it = tags.begin();
+       it != tags.end(); ++it) {
+    tag_to_bookmarks_[*it].erase(bookmark);
+    // Remove the tags no longer used.
+    if (!tag_to_bookmarks_[*it].size())
+      tag_to_bookmarks_.erase(*it);
+  }
+}