blob: d0c26f449ee8bb86bd3d4b4675434043160f10ad [file] [log] [blame]
// 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 <stdint.h>
#include <memory>
#include <unordered_set>
#include <utility>
#include "base/bind.h"
#include "base/files/file_path.h"
#include "base/guid.h"
#include "base/i18n/case_conversion.h"
#include "base/i18n/string_search.h"
#include "base/macros.h"
#include "base/metrics/user_metrics_action.h"
#include "base/stl_util.h"
#include "base/strings/string_util.h"
#include "base/strings/stringprintf.h"
#include "base/strings/utf_string_conversions.h"
#include "base/time/time.h"
#include "build/build_config.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/prefs/pref_service.h"
#include "components/query_parser/query_parser.h"
#include "components/url_formatter/url_formatter.h"
#include "ui/base/clipboard/clipboard.h"
#include "ui/base/models/tree_node_iterator.h"
#include "url/gurl.h"
using base::Time;
namespace bookmarks {
namespace {
// The maximum length of URL or title returned by the Cleanup functions.
const size_t kCleanedUpUrlMaxLength = 1024u;
const size_t kCleanedUpTitleMaxLength = 1024u;
void CloneBookmarkNodeImpl(BookmarkModel* model,
const BookmarkNodeData::Element& element,
const BookmarkNode* parent,
size_t index_to_add_at,
bool reset_node_times) {
// Make sure to not copy non clonable keys.
BookmarkNode::MetaInfoMap meta_info_map = element.meta_info_map;
for (const std::string& key : model->non_cloned_keys())
meta_info_map.erase(key);
if (element.is_url) {
Time date_added = reset_node_times ? Time::Now() : element.date_added;
DCHECK(!date_added.is_null());
model->AddURLWithCreationTimeAndMetaInfo(parent,
index_to_add_at,
element.title,
element.url,
date_added,
&meta_info_map);
} else {
const BookmarkNode* cloned_node = model->AddFolderWithMetaInfo(
parent, index_to_add_at, element.title, &meta_info_map);
if (!reset_node_times) {
DCHECK(!element.date_folder_modified.is_null());
model->SetDateFolderModified(cloned_node, element.date_folder_modified);
}
for (int i = 0; i < static_cast<int>(element.children.size()); ++i)
CloneBookmarkNodeImpl(model, element.children[i], cloned_node, i,
reset_node_times);
}
}
// Comparison function that compares based on date modified of the two nodes.
bool MoreRecentlyModified(const BookmarkNode* n1, const BookmarkNode* n2) {
return n1->date_folder_modified() > n2->date_folder_modified();
}
// Returns true if |text| contains each string in |words|. This is used when
// searching for bookmarks.
bool DoesBookmarkTextContainWords(const base::string16& text,
const std::vector<base::string16>& words) {
for (size_t i = 0; i < words.size(); ++i) {
if (!base::i18n::StringSearchIgnoringCaseAndAccents(words[i], text, nullptr,
nullptr)) {
return false;
}
}
return true;
}
// This is used with a tree iterator to skip subtrees which are not visible.
bool PruneInvisibleFolders(const BookmarkNode* node) {
return !node->IsVisible();
}
// This traces parents up to root, determines if node is contained in a
// selected folder.
bool HasSelectedAncestor(BookmarkModel* model,
const std::vector<const BookmarkNode*>& selected_nodes,
const BookmarkNode* node) {
if (!node || model->is_permanent_node(node))
return false;
for (size_t i = 0; i < selected_nodes.size(); ++i)
if (node->id() == selected_nodes[i]->id())
return true;
return HasSelectedAncestor(model, selected_nodes, node->parent());
}
const BookmarkNode* GetNodeByID(const BookmarkNode* node, int64_t id) {
if (node->id() == id)
return node;
for (const auto& child : node->children()) {
const BookmarkNode* result = GetNodeByID(child.get(), id);
if (result)
return result;
}
return nullptr;
}
// Attempts to shorten a URL safely (i.e., by preventing the end of the URL
// from being in the middle of an escape sequence) to no more than
// kCleanedUpUrlMaxLength characters, returning the result.
std::string TruncateUrl(const std::string& url) {
if (url.length() <= kCleanedUpUrlMaxLength)
return url;
// If we're in the middle of an escape sequence, truncate just before it.
if (url[kCleanedUpUrlMaxLength - 1] == '%')
return url.substr(0, kCleanedUpUrlMaxLength - 1);
if (url[kCleanedUpUrlMaxLength - 2] == '%')
return url.substr(0, kCleanedUpUrlMaxLength - 2);
return url.substr(0, kCleanedUpUrlMaxLength);
}
// Returns the URL from the clipboard. If there is no URL an empty URL is
// returned.
GURL GetUrlFromClipboard() {
base::string16 url_text;
#if !defined(OS_IOS)
ui::Clipboard::GetForCurrentThread()->ReadText(
ui::ClipboardBuffer::kCopyPaste, &url_text);
#endif
return GURL(url_text);
}
class VectorIterator {
public:
explicit VectorIterator(std::vector<const BookmarkNode*>* nodes)
: nodes_(nodes), current_(nodes->begin()) {}
bool has_next() { return (current_ != nodes_->end()); }
const BookmarkNode* Next() {
const BookmarkNode* result = *current_;
++current_;
return result;
}
private:
std::vector<const BookmarkNode*>* nodes_;
std::vector<const BookmarkNode*>::iterator current_;
DISALLOW_COPY_AND_ASSIGN(VectorIterator);
};
template <class type>
void GetBookmarksMatchingPropertiesImpl(
type& iterator,
BookmarkModel* model,
const QueryFields& query,
const std::vector<base::string16>& query_words,
size_t max_count,
std::vector<const BookmarkNode*>* nodes) {
while (iterator.has_next()) {
const BookmarkNode* node = iterator.Next();
if ((!query_words.empty() &&
!DoesBookmarkContainWords(node->GetTitle(), node->url(),
query_words)) ||
model->is_permanent_node(node)) {
continue;
}
if (query.title && node->GetTitle() != *query.title)
continue;
nodes->push_back(node);
if (nodes->size() == max_count)
return;
}
}
#if defined(OS_ANDROID)
// Returns whether or not a bookmark model contains any bookmarks aside of the
// permanent nodes.
bool HasUserCreatedBookmarks(BookmarkModel* model) {
const BookmarkNode* root_node = model->root_node();
return std::any_of(
root_node->children().cbegin(), root_node->children().cend(),
[](const auto& node) { return !node->children().empty(); });
}
#endif
} // namespace
QueryFields::QueryFields() {}
QueryFields::~QueryFields() {}
void CloneBookmarkNode(BookmarkModel* model,
const std::vector<BookmarkNodeData::Element>& elements,
const BookmarkNode* parent,
size_t index_to_add_at,
bool reset_node_times) {
if (!parent->is_folder() || !model) {
NOTREACHED();
return;
}
for (size_t i = 0; i < elements.size(); ++i) {
CloneBookmarkNodeImpl(model, elements[i], parent, index_to_add_at + i,
reset_node_times);
}
}
void CopyToClipboard(BookmarkModel* model,
const std::vector<const BookmarkNode*>& nodes,
bool remove_nodes) {
if (nodes.empty())
return;
// Create array of selected nodes with descendants filtered out.
std::vector<const BookmarkNode*> filtered_nodes;
for (size_t i = 0; i < nodes.size(); ++i)
if (!HasSelectedAncestor(model, nodes, nodes[i]->parent()))
filtered_nodes.push_back(nodes[i]);
BookmarkNodeData(filtered_nodes).WriteToClipboard();
if (remove_nodes) {
ScopedGroupBookmarkActions group_cut(model);
for (size_t i = 0; i < filtered_nodes.size(); ++i) {
int index = filtered_nodes[i]->parent()->GetIndexOf(filtered_nodes[i]);
if (index > -1)
model->Remove(filtered_nodes[i]);
}
}
}
// Updates |title| such that |url| and |title| pair are unique among the
// children of |parent|.
void MakeTitleUnique(const BookmarkModel* model,
const BookmarkNode* parent,
const GURL& url,
base::string16* title) {
std::unordered_set<base::string16> titles;
base::string16 original_title_lower = base::i18n::ToLower(*title);
for (const auto& node : parent->children()) {
if (node->is_url() && (url == node->url()) &&
base::StartsWith(base::i18n::ToLower(node->GetTitle()),
original_title_lower,
base::CompareCase::SENSITIVE)) {
titles.insert(node->GetTitle());
}
}
if (titles.find(*title) == titles.end())
return;
for (size_t i = 0; i < titles.size(); i++) {
const base::string16 new_title(*title +
base::ASCIIToUTF16(base::StringPrintf(
" (%lu)", (unsigned long)(i + 1))));
if (titles.find(new_title) == titles.end()) {
*title = new_title;
return;
}
}
NOTREACHED();
}
void PasteFromClipboard(BookmarkModel* model,
const BookmarkNode* parent,
size_t index) {
if (!parent)
return;
BookmarkNodeData bookmark_data;
if (!bookmark_data.ReadFromClipboard(ui::ClipboardBuffer::kCopyPaste)) {
GURL url = GetUrlFromClipboard();
if (!url.is_valid())
return;
BookmarkNode node(/*id=*/0, base::GenerateGUID(), url);
node.SetTitle(base::ASCIIToUTF16(url.spec()));
bookmark_data = BookmarkNodeData(&node);
}
DCHECK_LE(index, parent->children().size());
ScopedGroupBookmarkActions group_paste(model);
if (bookmark_data.size() == 1 &&
model->IsBookmarked(bookmark_data.elements[0].url)) {
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))
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))
continue;
if (parent->is_folder() && parent->date_folder_modified() > Time()) {
if (max_count == 0) {
nodes.push_back(parent);
} else {
auto 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 (const auto& node : root_node->children()) {
if (node->IsVisible() && model->client()->CanBeEditedByUser(node.get()) &&
!base::Contains(nodes, node.get())) {
nodes.push_back(node.get());
if (nodes.size() == max_count)
break;
}
}
}
return nodes;
}
void GetMostRecentlyAddedEntries(BookmarkModel* model,
size_t count,
std::vector<const BookmarkNode*>* nodes) {
ui::TreeNodeIterator<const BookmarkNode> iterator(model->root_node());
while (iterator.has_next()) {
const BookmarkNode* node = iterator.Next();
if (node->is_url()) {
auto insert_position = std::upper_bound(nodes->begin(), nodes->end(),
node, &MoreRecentlyAdded);
if (nodes->size() < count || insert_position != nodes->end()) {
nodes->insert(insert_position, node);
while (nodes->size() > count)
nodes->pop_back();
}
}
}
}
bool MoreRecentlyAdded(const BookmarkNode* n1, const BookmarkNode* n2) {
return n1->date_added() > n2->date_added();
}
void GetBookmarksMatchingProperties(BookmarkModel* model,
const QueryFields& query,
size_t max_count,
std::vector<const BookmarkNode*>* nodes) {
std::vector<base::string16> query_words = ParseBookmarkQuery(query);
if (query.word_phrase_query && query_words.empty())
return;
if (query.url) {
// Shortcut into the BookmarkModel if searching for URL.
GURL url(*query.url);
std::vector<const BookmarkNode*> url_matched_nodes;
if (url.is_valid())
model->GetNodesByURL(url, &url_matched_nodes);
VectorIterator iterator(&url_matched_nodes);
GetBookmarksMatchingPropertiesImpl<VectorIterator>(
iterator, model, query, query_words, max_count, nodes);
} else {
ui::TreeNodeIterator<const BookmarkNode> iterator(model->root_node());
GetBookmarksMatchingPropertiesImpl<
ui::TreeNodeIterator<const BookmarkNode>>(
iterator, model, query, query_words, max_count, nodes);
}
}
// Parses the provided query and returns a vector of query words.
std::vector<base::string16> ParseBookmarkQuery(
const bookmarks::QueryFields& query) {
std::vector<base::string16> query_words;
query_parser::QueryParser parser;
if (query.word_phrase_query) {
parser.ParseQueryWords(base::i18n::ToLower(*query.word_phrase_query),
query_parser::MatchingAlgorithm::DEFAULT,
&query_words);
}
return query_words;
}
// Returns true if |node|s title or url contains the strings in |words|.
bool DoesBookmarkContainWords(const base::string16& title,
const GURL& url,
const std::vector<base::string16>& words) {
return DoesBookmarkTextContainWords(title, words) ||
DoesBookmarkTextContainWords(base::UTF8ToUTF16(url.spec()), words) ||
DoesBookmarkTextContainWords(
url_formatter::FormatUrl(url, url_formatter::kFormatUrlOmitNothing,
net::UnescapeRule::NORMAL, nullptr,
nullptr, nullptr),
words);
}
void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry) {
registry->RegisterBooleanPref(
prefs::kShowBookmarkBar,
false,
user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
registry->RegisterBooleanPref(prefs::kEditBookmarksEnabled, true);
registry->RegisterBooleanPref(
prefs::kShowAppsShortcutInBookmarkBar,
true,
user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
registry->RegisterBooleanPref(
prefs::kShowManagedBookmarksInBookmarkBar,
true,
user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
RegisterManagedBookmarksPrefs(registry);
}
void RegisterManagedBookmarksPrefs(PrefRegistrySimple* registry) {
// Don't sync this, as otherwise, due to a limitation in sync, it
// will cause a deadlock (see http://crbug.com/97955). If we truly
// want to sync the expanded state of folders, it should be part of
// bookmark sync itself (i.e., a property of the sync folder nodes).
registry->RegisterListPref(prefs::kBookmarkEditorExpandedNodes);
registry->RegisterListPref(prefs::kManagedBookmarks);
registry->RegisterStringPref(
prefs::kManagedBookmarksFolderName, std::string());
}
const BookmarkNode* GetParentForNewNodes(
const BookmarkNode* parent,
const std::vector<const BookmarkNode*>& selection,
size_t* index) {
const BookmarkNode* real_parent = parent;
if (selection.size() == 1 && selection[0]->is_folder())
real_parent = selection[0];
if (index) {
if (selection.size() == 1 && selection[0]->is_url()) {
*index = size_t{real_parent->GetIndexOf(selection[0]) + 1};
DCHECK_NE(0u, *index);
} else {
*index = real_parent->children().size();
}
}
return real_parent;
}
void DeleteBookmarkFolders(BookmarkModel* model,
const std::vector<int64_t>& ids) {
// Remove the folders that were removed. This has to be done after all the
// other changes have been committed.
for (auto iter = ids.begin(); iter != ids.end(); ++iter) {
const BookmarkNode* node = GetBookmarkNodeByID(model, *iter);
if (!node)
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"));
const BookmarkNode* parent = GetParentForNewNodes(model);
model->AddURL(parent, parent->children().size(), 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))
model->Remove(node);
}
}
base::string16 CleanUpUrlForMatching(
const GURL& gurl,
base::OffsetAdjuster::Adjustments* adjustments) {
base::OffsetAdjuster::Adjustments tmp_adjustments;
return base::i18n::ToLower(url_formatter::FormatUrlWithAdjustments(
GURL(TruncateUrl(gurl.spec())),
url_formatter::kFormatUrlOmitUsernamePassword,
net::UnescapeRule::SPACES | net::UnescapeRule::PATH_SEPARATORS |
net::UnescapeRule::URL_SPECIAL_CHARS_EXCEPT_PATH_SEPARATORS,
nullptr, nullptr, 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*>& nodes) {
for (size_t i = 0; i < nodes.size(); ++i) {
if (!client->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]))
return true;
}
return false;
}
const BookmarkNode* GetBookmarkNodeByID(const BookmarkModel* model,
int64_t 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;
}
const BookmarkNode* GetParentForNewNodes(BookmarkModel* model) {
#if defined(OS_ANDROID)
if (!HasUserCreatedBookmarks(model))
return model->mobile_node();
#endif
std::vector<const BookmarkNode*> nodes =
GetMostRecentlyModifiedUserFolders(model, 1);
DCHECK(!nodes.empty()); // This list is always padded with default folders.
return nodes[0];
}
} // namespace bookmarks