Update all bookmarks which use an icon URL when a favicon's bitmap is updated

components/bookmarks/browser/bookmark_model.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/bookmarks/browser/bookmark_model.h"
 
 #include <algorithm>
 #include <functional>
 
 #include "base/bind.h"
@@ skipping 24 matching lines @@
 // Helper to get a mutable bookmark node.
 BookmarkNode* AsMutable(const BookmarkNode* node) {
   return const_cast<BookmarkNode*>(node);
 }
 
 // Helper to get a mutable permanent bookmark node.
 BookmarkPermanentNode* AsMutable(const BookmarkPermanentNode* node) {
   return const_cast<BookmarkPermanentNode*>(node);
 }
 
+// Removes |node| from |set|. This method is useful when the multiset has a
+// custom comparator.
+template<class T> void RemoveFromMultiset(
+    std::multiset<BookmarkNode*, T>* set,
+    BookmarkNode* node) {
+  std::multiset<BookmarkNode*>::iterator it = set->find(node);
+  if (it == set->end())
+    return;
+
+  while (*it != node)
+    ++it;
+  set->erase(it);
+}
+
 // Comparator used when sorting permanent nodes. Nodes that are initially
 // visible are sorted before nodes that are initially hidden.
 class VisibilityComparator
     : public std::binary_function<const BookmarkPermanentNode*,
                                   const BookmarkPermanentNode*,
                                   bool> {
  public:
   explicit VisibilityComparator(BookmarkClient* client) : client_(client) {}
 
   // Returns true if |n1| preceeds |n2|.
@@ skipping 284 matching lines @@
                     BookmarkNodeChanged(this, node));
 }
 
 void BookmarkModel::SetURL(const BookmarkNode* node, const GURL& url) {
   DCHECK(node && !node->is_folder());
 
   if (node->url() == url)
     return;
 
   BookmarkNode* mutable_node = AsMutable(node);
-  mutable_node->InvalidateFavicon();
-  CancelPendingFaviconLoadRequests(mutable_node);
+  InvalidateFavicon(mutable_node);
 
   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
                     OnWillChangeBookmarkNode(this, node));
 
   {
     base::AutoLock url_lock(url_lock_);
     RemoveNodeFromInternalMaps(mutable_node);
     mutable_node->set_url(url);
     AddNodeToInternalMaps(mutable_node);
   }
@@ skipping 67 matching lines @@
   DCHECK(client_->CanSyncNode(node));
 
   if (sync_transaction_version == node->sync_transaction_version())
     return;
 
   AsMutable(node)->set_sync_transaction_version(sync_transaction_version);
   if (store_.get())
     store_->ScheduleSave();
 }
 
-void BookmarkModel::OnFaviconChanged(const std::set<GURL>& urls) {
+void BookmarkModel::OnFaviconsChanged(const std::vector<GURL>& page_urls,
+                                      const std::vector<GURL>& icon_urls) {
   // Ignore events if |Load| has not been called yet.
   if (!store_)
     return;
 
-  // Prevent the observers from getting confused for multiple favicon loads.
-  for (std::set<GURL>::const_iterator i = urls.begin(); i != urls.end(); ++i) {
+  std::set<const BookmarkNode*> to_update;
+  for (const GURL& page_url : page_urls) {
     std::vector<const BookmarkNode*> nodes;
-    GetNodesByURL(*i, &nodes);
-    for (size_t i = 0; i < nodes.size(); ++i) {
-      // Got an updated favicon, for a URL, do a new request.
-      BookmarkNode* node = AsMutable(nodes[i]);
-      node->InvalidateFavicon();
-      CancelPendingFaviconLoadRequests(node);
-      FOR_EACH_OBSERVER(BookmarkModelObserver,
-                        observers_,
-                        BookmarkNodeFaviconChanged(this, node));
-    }
+    GetNodesByURL(page_url, &nodes);
+    for (const BookmarkNode* node : nodes)
+      to_update.insert(node);
+  }
+
+  for (const GURL& icon_url : icon_urls) {
+    std::vector<const BookmarkNode*> nodes;
+    GetNodesByIconURL(icon_url, &nodes);
+    for (const BookmarkNode* node : nodes)
+      to_update.insert(node);
+  }
+
+  for (const BookmarkNode* node : to_update) {
+    // Rerequest the favicon.
+    BookmarkNode* mutable_node = AsMutable(node);
+    InvalidateFavicon(mutable_node);
+    FOR_EACH_OBSERVER(BookmarkModelObserver,
+                      observers_,
+                      BookmarkNodeFaviconChanged(this, node));
   }
 }
 
 void BookmarkModel::SetDateAdded(const BookmarkNode* node, Time date_added) {
   DCHECK(node && !is_permanent_node(node));
 
   if (node->date_added() == date_added)
     return;
 
   AsMutable(node)->set_date_added(date_added);
@@ skipping 11 matching lines @@
                                   std::vector<const BookmarkNode*>* nodes) {
   base::AutoLock url_lock(url_lock_);
   BookmarkNode tmp_node(url);
   NodesOrderedByURLSet::iterator i = nodes_ordered_by_url_set_.find(&tmp_node);
   while (i != nodes_ordered_by_url_set_.end() && (*i)->url() == url) {
     nodes->push_back(*i);
     ++i;
   }
 }
 
+void BookmarkModel::GetNodesByIconURL(const GURL& icon_url,
+                                      std::vector<const BookmarkNode*>* nodes) {
+  BookmarkNode tmp_node = BookmarkNode(GURL());
+  tmp_node.set_icon_url(icon_url);
+  NodesOrderedByURLSet::iterator i =
+      nodes_ordered_by_favicon_url_set_.find(&tmp_node);
+  while (i != nodes_ordered_by_favicon_url_set_.end() &&
+         (*i)->icon_url() == icon_url) {
+    nodes->push_back(*i);
+    ++i;
+  }
+}
+
 const BookmarkNode* BookmarkModel::GetMostRecentlyAddedUserNodeForURL(
     const GURL& url) {
   std::vector<const BookmarkNode*> nodes;
   GetNodesByURL(url, &nodes);
   std::sort(nodes.begin(), nodes.end(), &MoreRecentlyAdded);
 
   // Look for the first node that the user can edit.
   for (size_t i = 0; i < nodes.size(); ++i) {
     if (client_->CanBeEditedByUser(nodes[i]))
       return nodes[i];
@@ skipping 346 matching lines @@
     store_->ScheduleSave();
 
   FOR_EACH_OBSERVER(
       BookmarkModelObserver,
       observers_,
       BookmarkNodeRemoved(this, parent, index, node.get(), removed_urls));
 }
 
 void BookmarkModel::RemoveNodeFromInternalMaps(BookmarkNode* node) {
   index_->Remove(node);
+  if (!node->icon_url().is_empty())
+    RemoveFromMultiset(&nodes_ordered_by_favicon_url_set_, node);
   // NOTE: this is called in such a way that url_lock_ is already held. As
   // such, this doesn't explicitly grab the lock.
   url_lock_.AssertAcquired();
-  NodesOrderedByURLSet::iterator i = nodes_ordered_by_url_set_.find(node);
-  DCHECK(i != nodes_ordered_by_url_set_.end());
-  // i points to the first node with the URL, advance until we find the
-  // node we're removing.
-  while (*i != node)
-    ++i;
-  nodes_ordered_by_url_set_.erase(i);
+  RemoveFromMultiset(&nodes_ordered_by_url_set_, node);
 }
 
 void BookmarkModel::RemoveNodeAndGetRemovedUrls(BookmarkNode* node,
                                                 std::set<GURL>* removed_urls) {
   // NOTE: this method should be always called with |url_lock_| held.
   // This method does not explicitly acquires a lock.
   url_lock_.AssertAcquired();
   DCHECK(removed_urls);
   BookmarkNode* parent = node->parent();
   DCHECK(parent);
@@ skipping 31 matching lines @@
   }
 
   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
                     BookmarkNodeAdded(this, parent, index));
 
   return node;
 }
 
 void BookmarkModel::AddNodeToInternalMaps(BookmarkNode* node) {
   index_->Add(node);
+  if (!node->icon_url().is_empty())
+    nodes_ordered_by_favicon_url_set_.insert(node);
   url_lock_.AssertAcquired();
   nodes_ordered_by_url_set_.insert(node);
 }
 
 bool BookmarkModel::IsValidIndex(const BookmarkNode* parent,
                                  int index,
                                  bool allow_end) {
   return (parent && parent->is_folder() &&
           (index >= 0 && (index < parent->child_count() ||
                           (allow_end && index == parent->child_count()))));
@@ skipping 30 matching lines @@
 }
 
 void BookmarkModel::OnFaviconDataAvailable(
     BookmarkNode* node,
     favicon_base::IconType icon_type,
     const favicon_base::FaviconImageResult& image_result) {
   DCHECK(node);
   node->set_favicon_load_task_id(base::CancelableTaskTracker::kBadTaskId);
   node->set_favicon_state(BookmarkNode::LOADED_FAVICON);
   if (!image_result.image.IsEmpty()) {
+    SetFaviconURL(node, image_result.icon_url);
     node->set_favicon_type(icon_type);
     node->set_favicon(image_result.image);
-    node->set_icon_url(image_result.icon_url);
+
     FaviconLoaded(node);
   } else if (icon_type == favicon_base::TOUCH_ICON) {
     // Couldn't load the touch icon, fallback to the regular favicon.
     DCHECK(client_->PreferTouchIcon());
     LoadFavicon(node, favicon_base::FAVICON);
   }
 }
 
 void BookmarkModel::LoadFavicon(BookmarkNode* node,
                                 favicon_base::IconType icon_type) {
@@ skipping 14 matching lines @@
           &cancelable_task_tracker_);
   if (taskId != base::CancelableTaskTracker::kBadTaskId)
     node->set_favicon_load_task_id(taskId);
 }
 
 void BookmarkModel::FaviconLoaded(const BookmarkNode* node) {
   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
                     BookmarkNodeFaviconChanged(this, node));
 }
 
+void BookmarkModel::SetFaviconURL(BookmarkNode* node, const GURL& icon_url) {
+  if (!node->icon_url().is_empty())
+    RemoveFromMultiset(&nodes_ordered_by_favicon_url_set_, node);
+  node->set_icon_url(icon_url);
+  if (!node->icon_url().is_empty())
+    nodes_ordered_by_favicon_url_set_.insert(node);
+}
+
+void BookmarkModel::InvalidateFavicon(BookmarkNode* node) {
+  SetFaviconURL(node, GURL());
+  node->set_favicon(gfx::Image());
+  node->set_favicon_type(favicon_base::INVALID_ICON);
+  node->set_favicon_state(BookmarkNode::INVALID_FAVICON);
+  CancelPendingFaviconLoadRequests(node);
+}
+
 void BookmarkModel::CancelPendingFaviconLoadRequests(BookmarkNode* node) {
   if (node->favicon_load_task_id() != base::CancelableTaskTracker::kBadTaskId) {
     cancelable_task_tracker_.TryCancel(node->favicon_load_task_id());
     node->set_favicon_load_task_id(base::CancelableTaskTracker::kBadTaskId);
   }
 }
 
 void BookmarkModel::PopulateNodesByURL(BookmarkNode* node) {
   // NOTE: this is called with url_lock_ already held. As such, this doesn't
   // explicitly grab the lock.
@@ skipping 18 matching lines @@
   return scoped_ptr<BookmarkLoadDetails>(new BookmarkLoadDetails(
       bb_node,
       other_node,
       mobile_node,
       client_->GetLoadExtraNodesCallback(),
       new BookmarkIndex(client_, accept_languages),
       next_node_id_));
 }
 
 }  // namespace bookmarks