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"
 #include "base/bind_helpers.h"
 #include "base/i18n/string_compare.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/metrics/histogram_macros.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/strings/string_util.h"
 #include "components/bookmarks/browser/bookmark_expanded_state_tracker.h"
 #include "components/bookmarks/browser/bookmark_index.h"
 #include "components/bookmarks/browser/bookmark_match.h"
 #include "components/bookmarks/browser/bookmark_model_observer.h"
 #include "components/bookmarks/browser/bookmark_node_data.h"
 #include "components/bookmarks/browser/bookmark_storage.h"
 #include "components/bookmarks/browser/bookmark_utils.h"
 #include "components/favicon_base/favicon_types.h"
@@ skipping 402 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);
+    mutable_node->InvalidateFavicon();
+    CancelPendingFaviconLoadRequests(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) {
+  // Log Histogram to determine how often this method is called in practice.

[sky, 2015/06/19 16:38:02]

WDYT of moving this to OnFaviconsChanged? What we care about there is both how
often it's called, and how many nodes are updated.

+  // TODO(pkotwicz): Do something more efficient if this method gets called many
+  // times a day for each user.
+  UMA_HISTOGRAM_BOOLEAN("Bookmarks.GetNodesByIconURL", true);
+
+  base::AutoLock url_lock(url_lock_);
+  for (const BookmarkNode* node : nodes_ordered_by_url_set_) {

[sky, 2015/06/19 16:38:02]

I prefer inlining this in OnFaviconsChanged and changing the ordering so you
loop through all the nodes seeing if the icon url of the node is in icon_urls.

+    if (node->icon_url() == icon_url)
+      nodes->push_back(node);
+  }
+}
+
 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 532 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