Index: chrome/browser/bookmarks/bookmark_model.cc |
=================================================================== |
--- chrome/browser/bookmarks/bookmark_model.cc (revision 1988) |
+++ chrome/browser/bookmarks/bookmark_model.cc (working copy) |
@@ -2,7 +2,7 @@ |
// 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_bar_model.h" |
+#include "chrome/browser/bookmarks/bookmark_model.h" |
#include "base/gfx/png_decoder.h" |
#include "chrome/browser/bookmarks/bookmark_storage.h" |
@@ -15,27 +15,27 @@ |
namespace { |
// Functions used for sorting. |
-bool MoreRecentlyModified(BookmarkBarNode* n1, BookmarkBarNode* n2) { |
+bool MoreRecentlyModified(BookmarkNode* n1, BookmarkNode* n2) { |
return n1->date_group_modified() > n2->date_group_modified(); |
} |
-bool MoreRecentlyAdded(BookmarkBarNode* n1, BookmarkBarNode* n2) { |
+bool MoreRecentlyAdded(BookmarkNode* n1, BookmarkNode* n2) { |
return n1->date_added() > n2->date_added(); |
} |
} // namespace |
-// BookmarkBarNode ------------------------------------------------------------ |
+// BookmarkNode --------------------------------------------------------------- |
namespace { |
-// ID for BookmarkBarNodes. |
+// ID for BookmarkNodes. |
// Various places assume an invalid id if == 0, for that reason we start with 1. |
int next_id_ = 1; |
} |
-const SkBitmap& BookmarkBarNode::GetFavIcon() { |
+const SkBitmap& BookmarkNode::GetFavIcon() { |
if (!loaded_favicon_) { |
loaded_favicon_ = true; |
model_->LoadFavIcon(this); |
@@ -43,7 +43,7 @@ |
return favicon_; |
} |
-BookmarkBarNode::BookmarkBarNode(BookmarkBarModel* model, const GURL& url) |
+BookmarkNode::BookmarkNode(BookmarkModel* model, const GURL& url) |
: model_(model), |
id_(next_id_++), |
loaded_favicon_(false), |
@@ -54,7 +54,7 @@ |
date_added_(Time::Now()) { |
} |
-void BookmarkBarNode::Reset(const history::StarredEntry& entry) { |
+void BookmarkNode::Reset(const history::StarredEntry& entry) { |
DCHECK(entry.type != history::StarredEntry::URL || |
entry.url == url_); |
@@ -65,9 +65,9 @@ |
SetTitle(entry.title); |
} |
-// BookmarkBarModel ----------------------------------------------------------- |
+// BookmarkModel -------------------------------------------------------------- |
-BookmarkBarModel::BookmarkBarModel(Profile* profile) |
+BookmarkModel::BookmarkModel(Profile* profile) |
: profile_(profile), |
loaded_(false), |
#pragma warning(suppress: 4355) // Okay to pass "this" here. |
@@ -77,7 +77,7 @@ |
waiting_for_history_load_(false), |
loaded_signal_(CreateEvent(NULL, TRUE, FALSE, NULL)) { |
// Create the bookmark bar and other bookmarks folders. These always exist. |
- CreateBookmarkBarNode(); |
+ CreateBookmarkNode(); |
CreateOtherBookmarksNode(); |
// And add them to the root. |
@@ -93,7 +93,7 @@ |
} |
} |
-BookmarkBarModel::~BookmarkBarModel() { |
+BookmarkModel::~BookmarkModel() { |
if (profile_ && store_.get()) { |
NotificationService::current()->RemoveObserver( |
this, NOTIFY_FAVICON_CHANGED, Source<Profile>(profile_)); |
@@ -104,7 +104,7 @@ |
this, NOTIFY_HISTORY_LOADED, Source<Profile>(profile_)); |
} |
- FOR_EACH_OBSERVER(BookmarkBarModelObserver, observers_, |
+ FOR_EACH_OBSERVER(BookmarkModelObserver, observers_, |
BookmarkModelBeingDeleted(this)); |
if (store_) { |
@@ -114,7 +114,7 @@ |
} |
} |
-void BookmarkBarModel::Load() { |
+void BookmarkModel::Load() { |
if (store_.get()) { |
// If the store is non-null, it means Load was already invoked. Load should |
// only be invoked once. |
@@ -132,16 +132,16 @@ |
store_->LoadBookmarks(false); |
} |
-BookmarkBarNode* BookmarkBarModel::GetParentForNewNodes() { |
- std::vector<BookmarkBarNode*> nodes; |
+BookmarkNode* BookmarkModel::GetParentForNewNodes() { |
+ std::vector<BookmarkNode*> nodes; |
GetMostRecentlyModifiedGroupNodes(&root_, 1, &nodes); |
return nodes.empty() ? bookmark_bar_node_ : nodes[0]; |
} |
-std::vector<BookmarkBarNode*> BookmarkBarModel::GetMostRecentlyModifiedGroups( |
+std::vector<BookmarkNode*> BookmarkModel::GetMostRecentlyModifiedGroups( |
size_t max_count) { |
- std::vector<BookmarkBarNode*> nodes; |
+ std::vector<BookmarkNode*> nodes; |
GetMostRecentlyModifiedGroupNodes(&root_, max_count, &nodes); |
if (nodes.size() < max_count) { |
@@ -157,13 +157,13 @@ |
return nodes; |
} |
-void BookmarkBarModel::GetMostRecentlyAddedEntries( |
+void BookmarkModel::GetMostRecentlyAddedEntries( |
size_t count, |
- std::vector<BookmarkBarNode*>* nodes) { |
+ std::vector<BookmarkNode*>* nodes) { |
AutoLock url_lock(url_lock_); |
for (NodesOrderedByURLSet::iterator i = nodes_ordered_by_url_set_.begin(); |
i != nodes_ordered_by_url_set_.end(); ++i) { |
- std::vector<BookmarkBarNode*>::iterator insert_position = |
+ std::vector<BookmarkNode*>::iterator insert_position = |
std::upper_bound(nodes->begin(), nodes->end(), *i, &MoreRecentlyAdded); |
if (nodes->size() < count || insert_position != nodes->end()) { |
nodes->insert(insert_position, *i); |
@@ -173,7 +173,7 @@ |
} |
} |
-void BookmarkBarModel::GetBookmarksMatchingText( |
+void BookmarkModel::GetBookmarksMatchingText( |
const std::wstring& text, |
size_t max_count, |
std::vector<TitleMatch>* matches) { |
@@ -198,7 +198,7 @@ |
} |
} |
-void BookmarkBarModel::Remove(BookmarkBarNode* parent, int index) { |
+void BookmarkModel::Remove(BookmarkNode* parent, int index) { |
if (!loaded_ || !IsValidIndex(parent, index, false) || parent == &root_) { |
NOTREACHED(); |
return; |
@@ -206,9 +206,9 @@ |
RemoveAndDeleteNode(parent->GetChild(index)); |
} |
-void BookmarkBarModel::Move(BookmarkBarNode* node, |
- BookmarkBarNode* new_parent, |
- int index) { |
+void BookmarkModel::Move(BookmarkNode* node, |
+ BookmarkNode* new_parent, |
+ int index) { |
if (!loaded_ || !node || !IsValidIndex(new_parent, index, true) || |
new_parent == &root_ || node == &root_ || node == bookmark_bar_node_ || |
node == other_node_) { |
@@ -224,7 +224,7 @@ |
SetDateGroupModified(new_parent, Time::Now()); |
- BookmarkBarNode* old_parent = node->GetParent(); |
+ BookmarkNode* old_parent = node->GetParent(); |
int old_index = old_parent->IndexOfChild(node); |
if (old_parent == new_parent && |
@@ -240,13 +240,13 @@ |
if (store_.get()) |
store_->ScheduleSave(); |
- FOR_EACH_OBSERVER(BookmarkBarModelObserver, observers_, |
+ FOR_EACH_OBSERVER(BookmarkModelObserver, observers_, |
BookmarkNodeMoved(this, old_parent, old_index, |
new_parent, index)); |
} |
-void BookmarkBarModel::SetTitle(BookmarkBarNode* node, |
- const std::wstring& title) { |
+void BookmarkModel::SetTitle(BookmarkNode* node, |
+ const std::wstring& title) { |
if (!node) { |
NOTREACHED(); |
return; |
@@ -259,18 +259,18 @@ |
if (store_.get()) |
store_->ScheduleSave(); |
- FOR_EACH_OBSERVER(BookmarkBarModelObserver, observers_, |
+ FOR_EACH_OBSERVER(BookmarkModelObserver, observers_, |
BookmarkNodeChanged(this, node)); |
} |
-BookmarkBarNode* BookmarkBarModel::GetNodeByURL(const GURL& url) { |
+BookmarkNode* BookmarkModel::GetNodeByURL(const GURL& url) { |
AutoLock url_lock(url_lock_); |
- BookmarkBarNode tmp_node(this, url); |
+ BookmarkNode tmp_node(this, url); |
NodesOrderedByURLSet::iterator i = nodes_ordered_by_url_set_.find(&tmp_node); |
return (i != nodes_ordered_by_url_set_.end()) ? *i : NULL; |
} |
-void BookmarkBarModel::GetBookmarks(std::vector<GURL>* urls) { |
+void BookmarkModel::GetBookmarks(std::vector<GURL>* urls) { |
AutoLock url_lock(url_lock_); |
for (NodesOrderedByURLSet::iterator i = nodes_ordered_by_url_set_.begin(); |
i != nodes_ordered_by_url_set_.end(); ++i) { |
@@ -278,13 +278,13 @@ |
} |
} |
-BookmarkBarNode* BookmarkBarModel::GetNodeByID(int id) { |
+BookmarkNode* BookmarkModel::GetNodeByID(int id) { |
// TODO(sky): TreeNode needs a method that visits all nodes using a predicate. |
return GetNodeByID(&root_, id); |
} |
-BookmarkBarNode* BookmarkBarModel::AddGroup( |
- BookmarkBarNode* parent, |
+BookmarkNode* BookmarkModel::AddGroup( |
+ BookmarkNode* parent, |
int index, |
const std::wstring& title) { |
if (!loaded_ || parent == &root_ || !IsValidIndex(parent, index, true)) { |
@@ -293,22 +293,22 @@ |
return NULL; |
} |
- BookmarkBarNode* new_node = new BookmarkBarNode(this, GURL()); |
+ BookmarkNode* new_node = new BookmarkNode(this, GURL()); |
new_node->SetTitle(title); |
new_node->type_ = history::StarredEntry::USER_GROUP; |
return AddNode(parent, index, new_node); |
} |
-BookmarkBarNode* BookmarkBarModel::AddURL(BookmarkBarNode* parent, |
- int index, |
- const std::wstring& title, |
- const GURL& url) { |
+BookmarkNode* BookmarkModel::AddURL(BookmarkNode* parent, |
+ int index, |
+ const std::wstring& title, |
+ const GURL& url) { |
return AddURLWithCreationTime(parent, index, title, url, Time::Now()); |
} |
-BookmarkBarNode* BookmarkBarModel::AddURLWithCreationTime( |
- BookmarkBarNode* parent, |
+BookmarkNode* BookmarkModel::AddURLWithCreationTime( |
+ BookmarkNode* parent, |
int index, |
const std::wstring& title, |
const GURL& url, |
@@ -319,7 +319,7 @@ |
return NULL; |
} |
- BookmarkBarNode* existing_node = GetNodeByURL(url); |
+ BookmarkNode* existing_node = GetNodeByURL(url); |
if (existing_node) { |
Move(existing_node, parent, index); |
SetTitle(existing_node, title); |
@@ -328,7 +328,7 @@ |
SetDateGroupModified(parent, creation_time); |
- BookmarkBarNode* new_node = new BookmarkBarNode(this, url); |
+ BookmarkNode* new_node = new BookmarkNode(this, url); |
new_node->SetTitle(title); |
new_node->date_added_ = creation_time; |
new_node->type_ = history::StarredEntry::URL; |
@@ -339,31 +339,31 @@ |
return AddNode(parent, index, new_node); |
} |
-void BookmarkBarModel::SetURLStarred(const GURL& url, |
- const std::wstring& title, |
- bool is_starred) { |
- BookmarkBarNode* node = GetNodeByURL(url); |
+void BookmarkModel::SetURLStarred(const GURL& url, |
+ const std::wstring& title, |
+ bool is_starred) { |
+ BookmarkNode* node = GetNodeByURL(url); |
if (is_starred && !node) { |
// Add the url. |
- BookmarkBarNode* parent = GetParentForNewNodes(); |
+ BookmarkNode* parent = GetParentForNewNodes(); |
AddURL(parent, parent->GetChildCount(), title, url); |
} else if (!is_starred && node) { |
Remove(node->GetParent(), node->GetParent()->IndexOfChild(node)); |
} |
} |
-void BookmarkBarModel::ResetDateGroupModified(BookmarkBarNode* node) { |
+void BookmarkModel::ResetDateGroupModified(BookmarkNode* node) { |
SetDateGroupModified(node, Time()); |
} |
-void BookmarkBarModel::FavIconLoaded(BookmarkBarNode* node) { |
+void BookmarkModel::FavIconLoaded(BookmarkNode* node) { |
// Send out notification to the observer. |
- FOR_EACH_OBSERVER(BookmarkBarModelObserver, observers_, |
+ FOR_EACH_OBSERVER(BookmarkModelObserver, observers_, |
BookmarkNodeFavIconLoaded(this, node)); |
} |
-void BookmarkBarModel::RemoveNode(BookmarkBarNode* node, |
- std::set<GURL>* removed_urls) { |
+void BookmarkModel::RemoveNode(BookmarkNode* node, |
+ std::set<GURL>* removed_urls) { |
if (!loaded_ || !node || node == &root_ || node == bookmark_bar_node_ || |
node == other_node_) { |
NOTREACHED(); |
@@ -386,7 +386,7 @@ |
RemoveNode(node->GetChild(i), removed_urls); |
} |
-void BookmarkBarModel::OnBookmarkStorageLoadedBookmarks( |
+void BookmarkModel::OnBookmarkStorageLoadedBookmarks( |
bool file_exists, |
bool loaded_from_history) { |
if (loaded_) { |
@@ -426,7 +426,7 @@ |
} |
} |
-void BookmarkBarModel::OnHistoryDone() { |
+void BookmarkModel::OnHistoryDone() { |
if (loaded_) { |
NOTREACHED(); |
return; |
@@ -437,7 +437,7 @@ |
store_->LoadBookmarks(true); |
} |
-void BookmarkBarModel::DoneLoading() { |
+void BookmarkModel::DoneLoading() { |
{ |
AutoLock url_lock(url_lock_); |
// Update nodes_ordered_by_url_set_ from the nodes. |
@@ -451,7 +451,7 @@ |
// Notify our direct observers. |
- FOR_EACH_OBSERVER(BookmarkBarModelObserver, observers_, Loaded(this)); |
+ FOR_EACH_OBSERVER(BookmarkModelObserver, observers_, Loaded(this)); |
// And generic notification. |
NotificationService::current()->Notify( |
@@ -460,10 +460,10 @@ |
NotificationService::NoDetails()); |
} |
-void BookmarkBarModel::RemoveAndDeleteNode(BookmarkBarNode* delete_me) { |
- scoped_ptr<BookmarkBarNode> node(delete_me); |
+void BookmarkModel::RemoveAndDeleteNode(BookmarkNode* delete_me) { |
+ scoped_ptr<BookmarkNode> node(delete_me); |
- BookmarkBarNode* parent = node->GetParent(); |
+ BookmarkNode* parent = node->GetParent(); |
DCHECK(parent); |
int index = parent->IndexOfChild(node.get()); |
parent->Remove(index); |
@@ -476,7 +476,7 @@ |
if (store_.get()) |
store_->ScheduleSave(); |
- FOR_EACH_OBSERVER(BookmarkBarModelObserver, observers_, |
+ FOR_EACH_OBSERVER(BookmarkModelObserver, observers_, |
BookmarkNodeRemoved(this, parent, index)); |
if (profile_) { |
@@ -491,15 +491,15 @@ |
Details<history::URLsStarredDetails>(&details)); |
} |
-BookmarkBarNode* BookmarkBarModel::AddNode(BookmarkBarNode* parent, |
- int index, |
- BookmarkBarNode* node) { |
+BookmarkNode* BookmarkModel::AddNode(BookmarkNode* parent, |
+ int index, |
+ BookmarkNode* node) { |
parent->Add(index, node); |
if (store_.get()) |
store_->ScheduleSave(); |
- FOR_EACH_OBSERVER(BookmarkBarModelObserver, observers_, |
+ FOR_EACH_OBSERVER(BookmarkModelObserver, observers_, |
BookmarkNodeAdded(this, parent, index)); |
if (node->GetType() == history::StarredEntry::URL) { |
@@ -512,34 +512,33 @@ |
return node; |
} |
-void BookmarkBarModel::BlockTillLoaded() { |
+void BookmarkModel::BlockTillLoaded() { |
if (loaded_signal_.Get()) |
WaitForSingleObject(loaded_signal_.Get(), INFINITE); |
} |
-BookmarkBarNode* BookmarkBarModel::GetNodeByID(BookmarkBarNode* node, |
- int id) { |
+BookmarkNode* BookmarkModel::GetNodeByID(BookmarkNode* node, int id) { |
if (node->id() == id) |
return node; |
for (int i = 0; i < node->GetChildCount(); ++i) { |
- BookmarkBarNode* result = GetNodeByID(node->GetChild(i), id); |
+ BookmarkNode* result = GetNodeByID(node->GetChild(i), id); |
if (result) |
return result; |
} |
return NULL; |
} |
-bool BookmarkBarModel::IsValidIndex(BookmarkBarNode* parent, |
- int index, |
- bool allow_end) { |
+bool BookmarkModel::IsValidIndex(BookmarkNode* parent, |
+ int index, |
+ bool allow_end) { |
return (parent && |
(index >= 0 && (index < parent->GetChildCount() || |
(allow_end && index == parent->GetChildCount())))); |
} |
-void BookmarkBarModel::SetDateGroupModified(BookmarkBarNode* parent, |
- const Time time) { |
+void BookmarkModel::SetDateGroupModified(BookmarkNode* parent, |
+ const Time time) { |
DCHECK(parent); |
parent->date_group_modified_ = time; |
@@ -547,23 +546,23 @@ |
store_->ScheduleSave(); |
} |
-void BookmarkBarModel::CreateBookmarkBarNode() { |
+void BookmarkModel::CreateBookmarkNode() { |
history::StarredEntry entry; |
entry.type = history::StarredEntry::BOOKMARK_BAR; |
bookmark_bar_node_ = CreateRootNodeFromStarredEntry(entry); |
} |
-void BookmarkBarModel::CreateOtherBookmarksNode() { |
+void BookmarkModel::CreateOtherBookmarksNode() { |
history::StarredEntry entry; |
entry.type = history::StarredEntry::OTHER; |
other_node_ = CreateRootNodeFromStarredEntry(entry); |
} |
-BookmarkBarNode* BookmarkBarModel::CreateRootNodeFromStarredEntry( |
+BookmarkNode* BookmarkModel::CreateRootNodeFromStarredEntry( |
const history::StarredEntry& entry) { |
DCHECK(entry.type == history::StarredEntry::BOOKMARK_BAR || |
entry.type == history::StarredEntry::OTHER); |
- BookmarkBarNode* node = new BookmarkBarNode(this, GURL()); |
+ BookmarkNode* node = new BookmarkNode(this, GURL()); |
node->Reset(entry); |
if (entry.type == history::StarredEntry::BOOKMARK_BAR) |
node->SetTitle(l10n_util::GetString(IDS_BOOMARK_BAR_FOLDER_NAME)); |
@@ -572,14 +571,14 @@ |
return node; |
} |
-void BookmarkBarModel::OnFavIconDataAvailable( |
+void BookmarkModel::OnFavIconDataAvailable( |
HistoryService::Handle handle, |
bool know_favicon, |
scoped_refptr<RefCountedBytes> data, |
bool expired, |
GURL icon_url) { |
SkBitmap fav_icon; |
- BookmarkBarNode* node = |
+ BookmarkNode* node = |
load_consumer_.GetClientData( |
profile_->GetHistoryService(Profile::EXPLICIT_ACCESS), handle); |
DCHECK(node); |
@@ -591,7 +590,7 @@ |
} |
} |
-void BookmarkBarModel::LoadFavIcon(BookmarkBarNode* node) { |
+void BookmarkModel::LoadFavIcon(BookmarkNode* node) { |
if (node->GetType() != history::StarredEntry::URL) |
return; |
@@ -603,12 +602,12 @@ |
HistoryService::Handle handle = history_service->GetFavIconForURL( |
node->GetURL(), &load_consumer_, |
- NewCallback(this, &BookmarkBarModel::OnFavIconDataAvailable)); |
+ NewCallback(this, &BookmarkModel::OnFavIconDataAvailable)); |
load_consumer_.SetClientData(history_service, handle, node); |
node->favicon_load_handle_ = handle; |
} |
-void BookmarkBarModel::CancelPendingFavIconLoadRequests(BookmarkBarNode* node) { |
+void BookmarkModel::CancelPendingFavIconLoadRequests(BookmarkNode* node) { |
if (node->favicon_load_handle_) { |
HistoryService* history = |
profile_->GetHistoryService(Profile::EXPLICIT_ACCESS); |
@@ -618,16 +617,16 @@ |
} |
} |
-void BookmarkBarModel::GetMostRecentlyModifiedGroupNodes( |
- BookmarkBarNode* parent, |
+void BookmarkModel::GetMostRecentlyModifiedGroupNodes( |
+ BookmarkNode* parent, |
size_t count, |
- std::vector<BookmarkBarNode*>* nodes) { |
+ std::vector<BookmarkNode*>* nodes) { |
if (parent != &root_ && parent->is_folder() && |
parent->date_group_modified() > Time()) { |
if (count == 0) { |
nodes->push_back(parent); |
} else { |
- std::vector<BookmarkBarNode*>::iterator i = |
+ std::vector<BookmarkNode*>::iterator i = |
std::upper_bound(nodes->begin(), nodes->end(), parent, |
&MoreRecentlyModified); |
if (nodes->size() < count || i != nodes->end()) { |
@@ -639,27 +638,27 @@ |
} // else case, the root node, which we don't care about or imported nodes |
// (which have a time of 0). |
for (int i = 0; i < parent->GetChildCount(); ++i) { |
- BookmarkBarNode* child = parent->GetChild(i); |
+ BookmarkNode* child = parent->GetChild(i); |
if (child->is_folder()) |
GetMostRecentlyModifiedGroupNodes(child, count, nodes); |
} |
} |
-void BookmarkBarModel::Observe(NotificationType type, |
- const NotificationSource& source, |
- const NotificationDetails& details) { |
+void BookmarkModel::Observe(NotificationType type, |
+ const NotificationSource& source, |
+ const NotificationDetails& details) { |
switch (type) { |
case NOTIFY_FAVICON_CHANGED: { |
// Prevent the observers from getting confused for multiple favicon loads. |
Details<history::FavIconChangeDetails> favicon_details(details); |
for (std::set<GURL>::const_iterator i = favicon_details->urls.begin(); |
i != favicon_details->urls.end(); ++i) { |
- BookmarkBarNode* node = GetNodeByURL(*i); |
+ BookmarkNode* node = GetNodeByURL(*i); |
if (node) { |
// Got an updated favicon, for a URL, do a new request. |
node->InvalidateFavicon(); |
CancelPendingFavIconLoadRequests(node); |
- FOR_EACH_OBSERVER(BookmarkBarModelObserver, observers_, |
+ FOR_EACH_OBSERVER(BookmarkModelObserver, observers_, |
BookmarkNodeChanged(this, node)); |
} |
} |
@@ -684,7 +683,7 @@ |
} |
} |
-void BookmarkBarModel::PopulateNodesByURL(BookmarkBarNode* node) { |
+void BookmarkModel::PopulateNodesByURL(BookmarkNode* node) { |
// NOTE: this is called with url_lock_ already held. As such, this doesn't |
// explicitly grab the lock. |
if (node->is_url()) |