Skip to content

GitLab

T
tangled
Commit fb19e5db authored by noyau@chromium.org's avatar noyau@chromium.org
Browse files
Options

Removing the bookmark tag model. 

This is not used for anything anymore.

BUG=None

Review URL: https://codereview.chromium.org/223813003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@261467 0039d316-1c4b-4281-b951-d872f2087c98
parent 574b2290
Show whitespace changes
Inline Side-by-side
Showing with 0 additions and 1415 deletions
chrome/browser/bookmarks/bookmark_tag_model.cc deleted 100644 → 0
View file @ 574b2290
// 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 =
base::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 base::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 base::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 = base::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::BookmarkModelLoaded(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_,
BookmarkTagModelLoaded(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);
}
}
chrome/browser/bookmarks/bookmark_tag_model.h deleted 100644 → 0
View file @ 574b2290
// 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.
#ifndef CHROME_BROWSER_BOOKMARKS_BOOKMARK_TAG_MODEL_H_
#define CHROME_BROWSER_BOOKMARKS_BOOKMARK_TAG_MODEL_H_
#include "chrome/browser/bookmarks/bookmark_model.h"
#include "chrome/browser/bookmarks/bookmark_model_observer.h"
class BookmarkTagModelObserver;
typedef base::string16 BookmarkTag;
// BookmarTagModel provides a way to access and manipulate bookmarks in a
// non-hierarchical way. BookmarkTagModel views the bookmarks as a flat list,
// and each one can be marked with a collection of tags (tags are simply
// strings).
//
// BookmarkTagModel converts on demand the data from an existing BookmarkModel
// to its view of the world. To do so it implicitly tags bookmarks with the
// title of their ancestor folders. This implicit tagging is made explicit on a
// bookmark when the BookmarkTagModel performs a change on the tags of this
// bookmark.
//
// The Bookmark's meta info is used for storage.
//
// An observer may be attached to a BookmarkTagModel to observe relevant events.
//
class BookmarkTagModel : public BookmarkModelObserver {
public:
explicit BookmarkTagModel(BookmarkModel* bookmark_model);
virtual ~BookmarkTagModel();
// Returns true once the model finishes loading. If any problems occurs during
// load an empty model is created instead.
bool loaded() const { return loaded_; }
// Add and remove observers on this object.
void AddObserver(BookmarkTagModelObserver* observer);
void RemoveObserver(BookmarkTagModelObserver* observer);
// Brackets an extensive set of changes, such as during import or sync, so
// observers can delay any expensive UI updates until it's finished.
class ExtensiveChanges {
public:
friend class BookmarkTagModel;
explicit ExtensiveChanges(BookmarkTagModel* model) : model_(model) {
model_->BeginExtensiveChanges();
}
private:
~ExtensiveChanges() {
model_->EndExtensiveChanges();
}
BookmarkTagModel* model_;
};
// Returns true if this bookmark model is currently in a mode where extensive
// changes might happen, such as for import and sync. This is helpful for
// observers that are created after the mode has started, and want to check
// state during their own initializer.
bool IsDoingExtensiveChanges() const;
// Removes the given |BookmarkNode|. Observers are notified immediately. The
// bookmark must be in the model.
void Remove(const BookmarkNode* bookmark);
// Removes all the bookmark nodes. Observers are only notified when all nodes
// have been removed. There is no notification for individual node removals.
void RemoveAll();
// Returns the favicon for |node|. If the favicon has not yet been
// loaded it is loaded and the observer of the model notified when done.
const gfx::Image& GetFavicon(const BookmarkNode* bookmark);
// Sets the title of |node|.
void SetTitle(const BookmarkNode* bookmark, const base::string16& title);
// Sets the URL of |node|.
void SetURL(const BookmarkNode* bookmark, const GURL& url);
// Sets the date added time of |node|.
void SetDateAdded(const BookmarkNode* bookmark, base::Time date_added);
// Returns the most recently added bookmark for the |url|. Returns NULL if
// |url| is not bookmarked.
const BookmarkNode* GetMostRecentlyAddedBookmarkForURL(const GURL& url);
// Creates a new bookmark.
const BookmarkNode* AddURL(const base::string16& title,
const GURL& url,
const std::set<BookmarkTag>& tags);
// Adds the |tags| to the tag list of the |bookmark|.
void AddTagsToBookmark(const std::set<BookmarkTag>& tags,
const BookmarkNode* bookmark);
// Same but to a whole collection of |bookmarks|.
void AddTagsToBookmarks(const std::set<BookmarkTag>& tags,
const std::set<const BookmarkNode*>& bookmarks);
// Remove the |tags| from the tag list of the |bookmark|. If the bookmark
// is not tagged with one or more of the tags, these are ignored.
void RemoveTagsFromBookmark(const std::set<BookmarkTag>& tags,
const BookmarkNode* bookmark);
// Same but to a whole collection of |bookmarks|.
void RemoveTagsFromBookmarks(const std::set<BookmarkTag>& tags,
const std::set<const BookmarkNode*>& bookmarks);
// Returns all the tags set on a specific |bookmark|.
std::set<BookmarkTag> GetTagsForBookmark(const BookmarkNode* bookmark);
// Returns the bookmarks marked with all the given |tags|.
std::set<const BookmarkNode*> BookmarksForTags(
const std::set<BookmarkTag>& tags);
// Returns the bookmarks marked with the given |tag|.
std::set<const BookmarkNode*> BookmarksForTag(const BookmarkTag& tag);
// Returns all tags related to the parent |tag|. If |tag| is null this method
// will returns and sort all tags in the system. A related tag is a tag used
// on one or more of the bookmarks tagged with |tag|. The returned tags are
// ordered from the most common to the rarest one.
std::vector<BookmarkTag> TagsRelatedToTag(const BookmarkTag& tag);
// All the BookmarkModelObserver methods. See there for details.
virtual void BookmarkModelLoaded(BookmarkModel* model,
bool ids_reassigned) OVERRIDE;
virtual void BookmarkModelBeingDeleted(BookmarkModel* model) OVERRIDE;
virtual void BookmarkNodeMoved(BookmarkModel* model,
const BookmarkNode* old_parent,
int old_index,
const BookmarkNode* new_parent,
int new_index) OVERRIDE;
virtual void BookmarkNodeAdded(BookmarkModel* model,
const BookmarkNode* parent,
int index) OVERRIDE;
virtual void OnWillRemoveBookmarks(BookmarkModel* model,
const BookmarkNode* parent,
int old_index,
const BookmarkNode* node) OVERRIDE;
virtual void BookmarkNodeRemoved(BookmarkModel* model,
const BookmarkNode* parent,
int old_index,
const BookmarkNode* node) OVERRIDE;
virtual void OnWillChangeBookmarkNode(BookmarkModel* model,
const BookmarkNode* node) OVERRIDE;
virtual void BookmarkNodeChanged(BookmarkModel* model,
const BookmarkNode* node) OVERRIDE;
virtual void OnWillChangeBookmarkMetaInfo(BookmarkModel* model,
const BookmarkNode* node) OVERRIDE;
virtual void BookmarkMetaInfoChanged(BookmarkModel* model,
const BookmarkNode* node) OVERRIDE;
virtual void BookmarkNodeFaviconChanged(BookmarkModel* model,
const BookmarkNode* node) OVERRIDE;
virtual void OnWillReorderBookmarkNode(BookmarkModel* model,
const BookmarkNode* node) OVERRIDE;
virtual void BookmarkNodeChildrenReordered(BookmarkModel* model,
const BookmarkNode* node) OVERRIDE;
virtual void ExtensiveBookmarkChangesBeginning(BookmarkModel* model) OVERRIDE;
virtual void ExtensiveBookmarkChangesEnded(BookmarkModel* model) OVERRIDE;
virtual void OnWillRemoveAllBookmarks(BookmarkModel* model) OVERRIDE;
virtual void BookmarkAllNodesRemoved(BookmarkModel* model) OVERRIDE;
private:
// Notifies the observers that an extensive set of changes is about to happen,
// such as during import or sync, so they can delay any expensive UI updates
// until it's finished.
void BeginExtensiveChanges();
void EndExtensiveChanges();
// Encode the tags in a format suitable for the BookmarkNode's metaInfo and
// set or replace the value.
void SetTagsOnBookmark(const std::set<BookmarkTag>& tags,
const BookmarkNode* bookmark);
// Build the caches of tag to bookmarks and bookmarks to tag for faster
// access to the data. Load() is called from the constructor if possible, or
// as soon as possible after that.
void Load();
// Discard tag information for all descendants of a given folder node and
// rebuild the cache for them.
void ReloadDescendants(const BookmarkNode* folder);
// Clear the local cache of all mentions of |bookmark|.
void RemoveBookmark(const BookmarkNode* bookmark);
// Extract the tags from |bookmark| and insert it in the local cache.
void LoadBookmark(const BookmarkNode* bookmark);
// The model from where the data is permanently stored.
BookmarkModel* bookmark_model_;
// True if the model is fully loaded.
bool loaded_;
// The observers.
ObserverList<BookmarkTagModelObserver> observers_;
// Local cache for quick access.
std::map<const BookmarkTag, std::set<const BookmarkNode*> > tag_to_bookmarks_;
std::map<const BookmarkNode*, std::set<BookmarkTag> > bookmark_to_tags_;
// Set to true during the creation of a new bookmark in order to send only the
// proper notification.
bool inhibit_change_notifications_;
DISALLOW_COPY_AND_ASSIGN(BookmarkTagModel);
};
#endif // CHROME_BROWSER_BOOKMARKS_BOOKMARK_TAG_MODEL_H_
chrome/browser/bookmarks/bookmark_tag_model_observer.h deleted 100644 → 0
View file @ 574b2290
// 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.
#ifndef CHROME_BROWSER_BOOKMARKS_BOOKMARK_TAG_MODEL_OBSERVER_H_
#define CHROME_BROWSER_BOOKMARKS_BOOKMARK_TAG_MODEL_OBSERVER_H_
class BookmarkTagModel;
class BookmarkNode;
// Observer for the BookmarkTagModel.
class BookmarkTagModelObserver {
public:
// Invoked when the model has finished loading.
virtual void BookmarkTagModelLoaded(BookmarkTagModel* model) = 0;
// Invoked from the destructor of the BookmarkTagModel.
virtual void BookmarkTagModelBeingDeleted(BookmarkTagModel* model) {}
// Invoked when a node has been added.
virtual void BookmarkNodeAdded(BookmarkTagModel* model,
const BookmarkNode* bookmark) = 0;
// Invoked before a node is removed.
// |node| is the node to be removed.
virtual void OnWillRemoveBookmarks(BookmarkTagModel* model,
const BookmarkNode* bookmark) {}
// Invoked when a node has been removed, |node| is the node that was removed.
virtual void BookmarkNodeRemoved(BookmarkTagModel* model,
const BookmarkNode* bookmark) = 0;
// Invoked before the title or url of a node is changed.
virtual void OnWillChangeBookmarkNode(BookmarkTagModel* model,
const BookmarkNode* bookmark) {}
// Invoked when the title or url of a node changes.
virtual void BookmarkNodeChanged(BookmarkTagModel* model,
const BookmarkNode* bookmark) = 0;
// Invoked before changing the tags of a node.
virtual void OnWillChangeBookmarkTags(BookmarkTagModel* model,
const BookmarkNode* bookmark) {}
// Invoked when tags are changed on a bookmark.
virtual void BookmarkTagsChanged(BookmarkTagModel* model,
const BookmarkNode* bookmark) = 0;
// Invoked when a favicon has been loaded or changed.
virtual void BookmarkNodeFaviconChanged(BookmarkTagModel* model,
const BookmarkNode* node) = 0;
// Invoked before an extensive set of model changes is about to begin.
// This tells UI intensive observers to wait until the updates finish to
// update themselves.
// These methods should only be used for imports and sync.
// Observers should still respond to BookmarkNodeRemoved immediately,
// to avoid holding onto stale node pointers.
virtual void ExtensiveBookmarkChangesBeginning(BookmarkTagModel* model) {}
// Invoked after an extensive set of model changes has ended.
// This tells observers to update themselves if they were waiting for the
// update to finish.
virtual void ExtensiveBookmarkChangesEnded(BookmarkTagModel* model) {}
// Invoked before all non-permanent bookmark nodes are removed.
virtual void OnWillRemoveAllBookmarks(BookmarkTagModel* model) {}
// Invoked when all non-permanent bookmark nodes have been removed.
virtual void BookmarkAllNodesRemoved(BookmarkTagModel* model) = 0;
protected:
virtual ~BookmarkTagModelObserver() {}
};
#endif // CHROME_BROWSER_BOOKMARKS_BOOKMARK_TAG_MODEL_OBSERVER_H_
chrome/browser/bookmarks/bookmark_tag_model_unittest.cc deleted 100644 → 0
View file @ 574b2290
// 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/strings/utf_string_conversions.h"
#include "chrome/browser/bookmarks/bookmark_tag_model_observer.h"
#include "testing/gtest/include/gtest/gtest.h"
using base::ASCIIToUTF16;
namespace {
static struct {
const std::string input_tag;
const std::string expected_tag;
} whitespace_test_cases[] = {
// Newlines.
{"foo\nbar", "foo bar"},
{"foo\n\nbar", "foo bar"},
{"foo\n\n\nbar", "foo bar"},
{"foo\r\nbar", "foo bar"},
{"foo\r\n\r\nbar", "foo bar"},
{"\nfoo\nbar\n", "foo bar"},
// Spaces.
{"foo bar", "foo bar"},
{" foo bar ", "foo bar"},
{" foo bar ", "foo bar"},
// Tabs.
{"\tfoo\tbar\t", "foo bar"},
{"\tfoo bar\t", "foo bar"},
// Mixed cases.
{"\tfoo\nbar\t", "foo bar"},
{"\tfoo\r\nbar\t", "foo bar"},
{" foo\tbar\n", "foo bar"},
{"\t foo \t bar \t", "foo bar"},
{"\n foo\r\n\tbar\n \t", "foo bar"},
};
enum ObserverCounts {
OBSERVER_COUNTS_ADD = 0,
OBSERVER_COUNTS_BEFORE_REMOVE,
OBSERVER_COUNTS_REMOVE,
OBSERVER_COUNTS_BEFORE_CHANGE,
OBSERVER_COUNTS_CHANGE,
OBSERVER_COUNTS_BEFORE_TAG_CHANGE,
OBSERVER_COUNTS_TAG_CHANGE,
OBSERVER_COUNTS_FAVICON_CHANGE,
OBSERVER_COUNTS_EXTENSIVE_CHANGE_BEGIN,
OBSERVER_COUNTS_EXTENSIVE_CHANGE_END,
OBSERVER_COUNTS_BEFORE_REMOVE_ALL,
OBSERVER_COUNTS_REMOVE_ALL,
OBSERVER_COUNTS_TOTAL_NUMBER_OF_COUNTS
};
const std::string count_name[] = {
"OBSERVER_COUNTS_ADD",
"OBSERVER_COUNTS_BEFORE_REMOVE",
"OBSERVER_COUNTS_REMOVE",
"OBSERVER_COUNTS_BEFORE_CHANGE",
"OBSERVER_COUNTS_CHANGE",
"OBSERVER_COUNTS_BEFORE_TAG_CHANGE",
"OBSERVER_COUNTS_TAG_CHANGE",
"OBSERVER_COUNTS_FAVICON_CHANGE",
"OBSERVER_COUNTS_EXTENSIVE_CHANGE_BEGIN",
"OBSERVER_COUNTS_EXTENSIVE_CHANGE_END",
"OBSERVER_COUNTS_BEFORE_REMOVE_ALL",
"OBSERVER_COUNTS_REMOVE_ALL"
};
class BookmarkTagModelTest
: public testing::Test, public BookmarkTagModelObserver {
public:
struct ObserverDetails {
ObserverDetails() : bookmark_(NULL) {}
void Set(const BookmarkNode* bookmark,
const std::set<BookmarkTag>& tags) {
bookmark_ = bookmark;
tags_ = tags;
}
void ExpectEquals(const BookmarkNode* bookmark,
const std::set<BookmarkTag>& tags) {
EXPECT_EQ(bookmark_, bookmark);
EXPECT_EQ(tags_, tags);
}
private:
const BookmarkNode* bookmark_;
std::set<BookmarkTag> tags_;
};
BookmarkTagModelTest() : model_(NULL),
tag_model_(new BookmarkTagModel(&model_)) {
tag_model_->AddObserver(this);
ClearCounts();
}
virtual ~BookmarkTagModelTest() {
}
// BookmarkTagModelObserver:
virtual void BookmarkTagModelLoaded(BookmarkTagModel* model) OVERRIDE {
// We never load from the db, so that this should never get invoked.
NOTREACHED();
}
// Invoked when a node has been added.
virtual void BookmarkNodeAdded(BookmarkTagModel* model,
const BookmarkNode* bookmark) OVERRIDE {
++counts_[OBSERVER_COUNTS_ADD];
observer_details_.Set(bookmark, model->GetTagsForBookmark(bookmark));
}
// Invoked before a node is removed.
// |node| is the node to be removed.
virtual void OnWillRemoveBookmarks(BookmarkTagModel* model,
const BookmarkNode* bookmark) OVERRIDE {
++counts_[OBSERVER_COUNTS_BEFORE_REMOVE];
}
// Invoked when a node has been removed, the item may still be starred though.
// |node| is the node that was removed.
virtual void BookmarkNodeRemoved(BookmarkTagModel* model,
const BookmarkNode* bookmark) OVERRIDE {
++counts_[OBSERVER_COUNTS_REMOVE];
}
// Invoked before the title or url of a node is changed.
virtual void OnWillChangeBookmarkNode(BookmarkTagModel* model,
const BookmarkNode* bookmark) OVERRIDE {
++counts_[OBSERVER_COUNTS_BEFORE_CHANGE];
}
// Invoked when the title or url of a node changes.
virtual void BookmarkNodeChanged(BookmarkTagModel* model,
const BookmarkNode* bookmark) OVERRIDE {
++counts_[OBSERVER_COUNTS_CHANGE];
observer_details_.Set(bookmark, model->GetTagsForBookmark(bookmark));
}
virtual void OnWillChangeBookmarkTags(BookmarkTagModel* model,
const BookmarkNode* bookmark) OVERRIDE {
++counts_[OBSERVER_COUNTS_BEFORE_TAG_CHANGE];
}
virtual void BookmarkTagsChanged(BookmarkTagModel* model,
const BookmarkNode* bookmark) OVERRIDE {
++counts_[OBSERVER_COUNTS_TAG_CHANGE];
observer_details_.Set(bookmark, model->GetTagsForBookmark(bookmark));
}
virtual void BookmarkNodeFaviconChanged(BookmarkTagModel* model,
const BookmarkNode* node) OVERRIDE {
++counts_[OBSERVER_COUNTS_FAVICON_CHANGE];
}
virtual void ExtensiveBookmarkChangesBeginning(BookmarkTagModel* model)
OVERRIDE {
++counts_[OBSERVER_COUNTS_EXTENSIVE_CHANGE_BEGIN];
}
virtual void ExtensiveBookmarkChangesEnded(BookmarkTagModel* model) OVERRIDE {
++counts_[OBSERVER_COUNTS_EXTENSIVE_CHANGE_END];
}
virtual void OnWillRemoveAllBookmarks(BookmarkTagModel* model) OVERRIDE {
++counts_[OBSERVER_COUNTS_BEFORE_REMOVE_ALL];
}
virtual void BookmarkAllNodesRemoved(BookmarkTagModel* model) OVERRIDE {
++counts_[OBSERVER_COUNTS_REMOVE_ALL];
}
void ClearCounts() {
for (unsigned int i = 0; i < OBSERVER_COUNTS_TOTAL_NUMBER_OF_COUNTS; ++i)
counts_[i] = 0;
}
void AssertAndClearObserverCount(ObserverCounts count, int expected) {
ASSERT_EQ(expected, counts_[count]) << count_name[count];
counts_[count] = 0;
}
void AssertAllCountsClear() {
for (unsigned int i = 0; i < OBSERVER_COUNTS_TOTAL_NUMBER_OF_COUNTS; ++i)
ASSERT_EQ(0, counts_[i]) << count_name[i];
}
const BookmarkNode* AddURLWithTags(
const std::string& name,
const std::set<BookmarkTag>& tags) {
const base::string16 title(ASCIIToUTF16(name));
const GURL url("http://" + name + ".com");
return tag_model_->AddURL(title, url, tags);
}
protected:
BookmarkModel model_;
scoped_ptr<BookmarkTagModel> tag_model_;
ObserverDetails observer_details_;
private:
int counts_[OBSERVER_COUNTS_TOTAL_NUMBER_OF_COUNTS];
DISALLOW_COPY_AND_ASSIGN(BookmarkTagModelTest);
};
TEST_F(BookmarkTagModelTest, InitialState) {
std::vector<BookmarkTag> tags(tag_model_->TagsRelatedToTag(base::string16()));
EXPECT_EQ(0UL, tags.size());
}
TEST_F(BookmarkTagModelTest, AddURL) {
std::set<BookmarkTag> tags;
tags.insert(ASCIIToUTF16("bar"));
tags.insert(ASCIIToUTF16("baz"));
AddURLWithTags("orly", tags);
const BookmarkNode* new_node = AddURLWithTags("foo", tags);
AssertAndClearObserverCount(OBSERVER_COUNTS_ADD, 2);
AssertAllCountsClear();
observer_details_.ExpectEquals(new_node, tags);
EXPECT_EQ(2UL, tag_model_->BookmarksForTag(ASCIIToUTF16("bar")).size());
EXPECT_EQ(2UL, tag_model_->BookmarksForTag(ASCIIToUTF16("baz")).size());
EXPECT_EQ(tags, tag_model_->GetTagsForBookmark(new_node));
std::vector<BookmarkTag> alltags(
tag_model_->TagsRelatedToTag(base::string16()));
EXPECT_EQ(2UL, alltags.size());
}
TEST_F(BookmarkTagModelTest, RelatedTo) {
std::set<BookmarkTag> tags;
tags.insert(ASCIIToUTF16("bar"));
tags.insert(ASCIIToUTF16("baz"));
AddURLWithTags("orly", tags);
AddURLWithTags("foo", tags);
AssertAndClearObserverCount(OBSERVER_COUNTS_ADD, 2);
AssertAllCountsClear();
std::vector<BookmarkTag> bartags(tag_model_->TagsRelatedToTag(
ASCIIToUTF16("bar")));
EXPECT_EQ(1UL, bartags.size());
std::vector<BookmarkTag> baztags(tag_model_->TagsRelatedToTag(
ASCIIToUTF16("baz")));
EXPECT_EQ(1UL, baztags.size());
}
TEST_F(BookmarkTagModelTest, AddURLWithWhitespaceTitle) {
std::set<BookmarkTag> tags;
for (size_t i = 0; i < ARRAYSIZE_UNSAFE(whitespace_test_cases); ++i) {
const BookmarkNode* new_node = AddURLWithTags(
whitespace_test_cases[i].input_tag, tags);
EXPECT_EQ(ASCIIToUTF16(whitespace_test_cases[i].expected_tag),
new_node->GetTitle());
EXPECT_EQ(BookmarkNode::URL, new_node->type());
}
}
TEST_F(BookmarkTagModelTest, CheckTagsWithWhitespace) {
std::set<BookmarkTag> tags;
for (size_t i = 0; i < ARRAYSIZE_UNSAFE(whitespace_test_cases); ++i)
tags.insert(ASCIIToUTF16(whitespace_test_cases[i].input_tag));
AddURLWithTags("foo", tags);
std::vector<BookmarkTag> alltags(tag_model_->TagsRelatedToTag(
base::string16()));
for (size_t i = 0; i < ARRAYSIZE_UNSAFE(whitespace_test_cases); ++i) {
EXPECT_EQ(0UL, tag_model_->BookmarksForTag(
ASCIIToUTF16(whitespace_test_cases[i].input_tag)).size());
EXPECT_EQ(1UL, tag_model_->BookmarksForTag(
ASCIIToUTF16(whitespace_test_cases[i].expected_tag)).size());
}
}
TEST_F(BookmarkTagModelTest, RemoveURL) {
std::set<BookmarkTag> tags;
tags.insert(ASCIIToUTF16("bar"));
tags.insert(ASCIIToUTF16("baz"));
const BookmarkNode* new_node = AddURLWithTags("foo", tags);
const BookmarkNode* new_node2 = AddURLWithTags("flou", tags);
ClearCounts();
tag_model_->Remove(new_node);
tag_model_->Remove(new_node2);
AssertAndClearObserverCount(OBSERVER_COUNTS_BEFORE_REMOVE, 2);
AssertAndClearObserverCount(OBSERVER_COUNTS_REMOVE, 2);
AssertAllCountsClear();
std::vector<BookmarkTag> alltags(tag_model_->TagsRelatedToTag(
base::string16()));
EXPECT_EQ(0UL, alltags.size());
}
TEST_F(BookmarkTagModelTest, AddTagToBookmarks) {
std::set<BookmarkTag> tags;
tags.insert(ASCIIToUTF16("bar"));
tags.insert(ASCIIToUTF16("baz"));
std::set<const BookmarkNode*> bookmarks;
bookmarks.insert(AddURLWithTags("foo", tags));
bookmarks.insert(AddURLWithTags("flou", tags));
ClearCounts();
std::set<BookmarkTag> new_tags;
new_tags.insert(ASCIIToUTF16("new_bar"));
new_tags.insert(ASCIIToUTF16("new_baz"));
tag_model_->AddTagsToBookmarks(new_tags, bookmarks);
AssertAndClearObserverCount(OBSERVER_COUNTS_BEFORE_TAG_CHANGE, 2);
AssertAndClearObserverCount(OBSERVER_COUNTS_TAG_CHANGE, 2);
AssertAllCountsClear();
std::vector<BookmarkTag> alltags(tag_model_->TagsRelatedToTag(
base::string16()));
EXPECT_EQ(4UL, alltags.size());
}
TEST_F(BookmarkTagModelTest, AddTagToBookmark) {
std::set<BookmarkTag> tags;
tags.insert(ASCIIToUTF16("bar"));
tags.insert(ASCIIToUTF16("baz"));
const BookmarkNode* bookmark = AddURLWithTags("foo", tags);
ClearCounts();
std::set<BookmarkTag> new_tags;
new_tags.insert(ASCIIToUTF16("new_bar"));
new_tags.insert(ASCIIToUTF16("new_baz"));
tag_model_->AddTagsToBookmark(new_tags, bookmark);
AssertAndClearObserverCount(OBSERVER_COUNTS_BEFORE_TAG_CHANGE, 1);
AssertAndClearObserverCount(OBSERVER_COUNTS_TAG_CHANGE, 1);
AssertAllCountsClear();
std::vector<BookmarkTag> alltags(tag_model_->TagsRelatedToTag(
base::string16()));
EXPECT_EQ(4UL, alltags.size());
}
TEST_F(BookmarkTagModelTest, RemoveTagFromBookmarks) {
std::set<BookmarkTag> tags;
tags.insert(ASCIIToUTF16("bar"));
tags.insert(ASCIIToUTF16("baz"));
std::set<const BookmarkNode*> bookmarks;
bookmarks.insert(AddURLWithTags("foo", tags));
bookmarks.insert(AddURLWithTags("flou", tags));
ClearCounts();
tag_model_->RemoveTagsFromBookmarks(tags, bookmarks);
AssertAndClearObserverCount(OBSERVER_COUNTS_BEFORE_TAG_CHANGE, 2);
AssertAndClearObserverCount(OBSERVER_COUNTS_TAG_CHANGE, 2);
AssertAllCountsClear();
std::vector<BookmarkTag> alltags(tag_model_->TagsRelatedToTag(
base::string16()));
EXPECT_EQ(0UL, alltags.size());
}
TEST_F(BookmarkTagModelTest, RemoveTagFromBookmark) {
std::set<BookmarkTag> tags;
tags.insert(ASCIIToUTF16("bar"));
tags.insert(ASCIIToUTF16("baz"));
const BookmarkNode* bookmark = AddURLWithTags("foo", tags);
ClearCounts();
tag_model_->RemoveTagsFromBookmark(tags, bookmark);
AssertAndClearObserverCount(OBSERVER_COUNTS_BEFORE_TAG_CHANGE, 1);
AssertAndClearObserverCount(OBSERVER_COUNTS_TAG_CHANGE, 1);
AssertAllCountsClear();
std::vector<BookmarkTag> alltags(tag_model_->TagsRelatedToTag(
base::string16()));
EXPECT_EQ(0UL, alltags.size());
}
TEST_F(BookmarkTagModelTest, RemoveAll) {
std::set<BookmarkTag> tags;
tags.insert(ASCIIToUTF16("bar"));
tags.insert(ASCIIToUTF16("baz"));
AddURLWithTags("foo", tags);
ClearCounts();
model_.RemoveAll();
AssertAndClearObserverCount(OBSERVER_COUNTS_EXTENSIVE_CHANGE_BEGIN, 1);
AssertAndClearObserverCount(OBSERVER_COUNTS_BEFORE_REMOVE_ALL, 1);
AssertAndClearObserverCount(OBSERVER_COUNTS_REMOVE_ALL, 1);
AssertAndClearObserverCount(OBSERVER_COUNTS_EXTENSIVE_CHANGE_END, 1);
AssertAllCountsClear();
std::vector<BookmarkTag> alltags(tag_model_->TagsRelatedToTag(
base::string16()));
EXPECT_EQ(0UL, alltags.size());
}
TEST_F(BookmarkTagModelTest, DuplicateFolders) {
const BookmarkNode* left = model_.AddFolder(model_.bookmark_bar_node(), 0,
ASCIIToUTF16("left"));
const BookmarkNode* right = model_.AddFolder(model_.bookmark_bar_node(), 0,
ASCIIToUTF16("right"));
const BookmarkNode* left_handed = model_.AddFolder(left, 0,
ASCIIToUTF16("handed"));
const BookmarkNode* right_handed = model_.AddFolder(right, 0,
ASCIIToUTF16("handed"));
model_.AddURL(
left_handed, 0, ASCIIToUTF16("red"), GURL("http://random.com"));
model_.AddURL(
right_handed, 0, ASCIIToUTF16("der"), GURL("http://random.com"));
EXPECT_EQ(2UL, tag_model_->BookmarksForTag(ASCIIToUTF16("handed")).size());
EXPECT_EQ(1UL, tag_model_->BookmarksForTag(ASCIIToUTF16("left")).size());
EXPECT_EQ(1UL, tag_model_->BookmarksForTag(ASCIIToUTF16("right")).size());
std::set<BookmarkTag> tags;
tags.insert(ASCIIToUTF16("left"));
tags.insert(ASCIIToUTF16("handed"));
EXPECT_EQ(1UL, tag_model_->BookmarksForTags(tags).size());
}
class PreloadedBookmarkTagModelTest : public BookmarkTagModelTest {
public:
PreloadedBookmarkTagModelTest() : BookmarkTagModelTest() {
PopulateUnderlyingModel();
}
void PopulateUnderlyingModel() {
ClearCounts();
top_node_ = model_.AddURL(model_.bookmark_bar_node(), 0,
ASCIIToUTF16("Tagless"), GURL("http://example.com"));
folder_1_ = model_.AddFolder(model_.bookmark_bar_node(), 0,
ASCIIToUTF16("folder1"));
one_tag_ = model_.AddURL(folder_1_, 0, ASCIIToUTF16("OneTag"),
GURL("http://random.com"));
folder_2_ = model_.AddFolder(folder_1_, 0, ASCIIToUTF16("folder2"));
two_tags_ = model_.AddURL(folder_2_, 0, ASCIIToUTF16("TwoTags"),
GURL("http://moveit.com"));
AssertAndClearObserverCount(OBSERVER_COUNTS_ADD, 3);
AssertAllCountsClear();
}
void AssertModelMatches() {
EXPECT_EQ(2UL, tag_model_->BookmarksForTag(ASCIIToUTF16("folder1")).size());
EXPECT_EQ(1UL, tag_model_->BookmarksForTag(ASCIIToUTF16("folder2")).size());
std::set<BookmarkTag> tags;
tags.insert(ASCIIToUTF16("folder1"));
EXPECT_EQ(tags, tag_model_->GetTagsForBookmark(one_tag_));
tags.insert(ASCIIToUTF16("folder2"));
const BookmarkNode* two_tags = tag_model_->
GetMostRecentlyAddedBookmarkForURL(GURL("http://moveit.com"));
EXPECT_EQ(tags, tag_model_->GetTagsForBookmark(two_tags));
std::vector<BookmarkTag> alltags(tag_model_->TagsRelatedToTag(
base::string16()));
EXPECT_EQ(2UL, alltags.size());
}
protected:
const BookmarkNode* folder_1_;
const BookmarkNode* folder_2_;
const BookmarkNode* top_node_;
const BookmarkNode* one_tag_;
const BookmarkNode* two_tags_;
DISALLOW_COPY_AND_ASSIGN(PreloadedBookmarkTagModelTest);
};
TEST_F(PreloadedBookmarkTagModelTest, InitialState) {
AssertAllCountsClear();
AssertModelMatches();
}
TEST_F(PreloadedBookmarkTagModelTest, FromExistingState) {
tag_model_.reset(new BookmarkTagModel(&model_));
tag_model_->AddObserver(this);
AssertAllCountsClear();
AssertModelMatches();
}
TEST_F(PreloadedBookmarkTagModelTest, BookmarkChange) {
AssertAllCountsClear();
tag_model_->SetTitle(top_node_, ASCIIToUTF16("newname"));
AssertAndClearObserverCount(OBSERVER_COUNTS_BEFORE_CHANGE, 1);
AssertAndClearObserverCount(OBSERVER_COUNTS_CHANGE, 1);
AssertAllCountsClear();
}
TEST_F(PreloadedBookmarkTagModelTest, UnchangedBookmarkMove) {
AssertAllCountsClear();
model_.Move(top_node_, folder_2_, 0);
AssertAndClearObserverCount(OBSERVER_COUNTS_BEFORE_TAG_CHANGE, 1);
AssertAndClearObserverCount(OBSERVER_COUNTS_TAG_CHANGE, 1);
AssertAllCountsClear();
}
TEST_F(PreloadedBookmarkTagModelTest, ChangedBookmarkMove) {
std::set<BookmarkTag> tags;
tags.insert(ASCIIToUTF16("bar"));
AssertAllCountsClear();
tag_model_->AddTagsToBookmark(tags, top_node_);
AssertAndClearObserverCount(OBSERVER_COUNTS_BEFORE_TAG_CHANGE, 1);
AssertAndClearObserverCount(OBSERVER_COUNTS_TAG_CHANGE, 1);
AssertAllCountsClear();
model_.Move(top_node_, folder_2_, 0);
AssertAllCountsClear();
}
TEST_F(PreloadedBookmarkTagModelTest, DuplicateBookmark) {
EXPECT_EQ(2UL, tag_model_->BookmarksForTag(folder_1_->GetTitle()).size());
model_.AddURL(folder_1_, 0, one_tag_->GetTitle(), one_tag_->url());
EXPECT_EQ(3UL, tag_model_->BookmarksForTag(folder_1_->GetTitle()).size());
}
TEST_F(PreloadedBookmarkTagModelTest, NamelessFolders) {
const BookmarkNode* folder = model_.AddFolder(model_.bookmark_bar_node(), 0,
ASCIIToUTF16(""));
model_.AddURL(folder, 0, ASCIIToUTF16("StillNotag"),
GURL("http://random.com"));
AssertModelMatches();
}
TEST_F(PreloadedBookmarkTagModelTest, FolderNameChange) {
EXPECT_EQ(2UL, tag_model_->BookmarksForTag(folder_1_->GetTitle()).size());
model_.SetTitle(folder_1_, ASCIIToUTF16("Bummer"));
AssertAndClearObserverCount(OBSERVER_COUNTS_EXTENSIVE_CHANGE_BEGIN, 1);
AssertAndClearObserverCount(OBSERVER_COUNTS_EXTENSIVE_CHANGE_END, 1);
AssertAndClearObserverCount(OBSERVER_COUNTS_BEFORE_TAG_CHANGE, 2);
AssertAndClearObserverCount(OBSERVER_COUNTS_TAG_CHANGE, 2);
AssertAllCountsClear();
EXPECT_EQ(2UL, tag_model_->BookmarksForTag(folder_1_->GetTitle()).size());
}
TEST_F(PreloadedBookmarkTagModelTest, FolderMoved) {
EXPECT_EQ(2UL, tag_model_->BookmarksForTag(folder_1_->GetTitle()).size());
model_.Move(folder_2_, model_.bookmark_bar_node(), 0);
AssertAndClearObserverCount(OBSERVER_COUNTS_EXTENSIVE_CHANGE_BEGIN, 1);
AssertAndClearObserverCount(OBSERVER_COUNTS_EXTENSIVE_CHANGE_END, 1);
AssertAndClearObserverCount(OBSERVER_COUNTS_BEFORE_TAG_CHANGE, 1);
AssertAndClearObserverCount(OBSERVER_COUNTS_TAG_CHANGE, 1);
AssertAllCountsClear();
EXPECT_EQ(1UL, tag_model_->BookmarksForTag(folder_1_->GetTitle()).size());
}
} // namespace
chrome/chrome_browser.gypi
View file @ fb19e5db
......@@ -305,9 +305,6 @@
'browser/bookmarks/bookmark_stats.h',
'browser/bookmarks/bookmark_storage.cc',
'browser/bookmarks/bookmark_storage.h',
'browser/bookmarks/bookmark_tag_model.cc',
'browser/bookmarks/bookmark_tag_model.h',
'browser/bookmarks/bookmark_tag_model_observer.h',
'browser/bookmarks/bookmark_title_match.cc',
'browser/bookmarks/bookmark_title_match.h',
'browser/bookmarks/bookmark_utils.cc',
......
chrome/chrome_tests_unit.gypi
View file @ fb19e5db
......@@ -625,7 +625,6 @@
'browser/bookmarks/bookmark_index_unittest.cc',
'browser/bookmarks/bookmark_model_unittest.cc',
'browser/bookmarks/bookmark_node_data_unittest.cc',
'browser/bookmarks/bookmark_tag_model_unittest.cc',
'browser/bookmarks/bookmark_utils_unittest.cc',
'browser/browser_about_handler_unittest.cc',
'browser/browser_commands_unittest.cc',
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment