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

components/history/core/browser/history_backend.cc

 // Copyright (c) 2012 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/history/core/browser/history_backend.h"
 
 #include <algorithm>
 #include <functional>
 #include <list>
 #include <map>
@@ skipping 1570 matching lines @@
     const GURL& icon_url,
     favicon_base::IconType icon_type,
     scoped_refptr<base::RefCountedMemory> bitmap_data,
     const gfx::Size& pixel_size) {
   if (!thumbnail_db_ || !db_)
     return;
 
   favicon_base::FaviconID favicon_id =
       thumbnail_db_->GetFaviconIDForFaviconURL(icon_url, icon_type, nullptr);
 
+  bool favicon_created = false;
   if (!favicon_id) {
     // There is no favicon at |icon_url|, create it.
     favicon_id = thumbnail_db_->AddFavicon(icon_url, icon_type);
+    favicon_created = true;
   }
 
   std::vector<FaviconBitmapIDSize> bitmap_id_sizes;
   thumbnail_db_->GetFaviconBitmapIDSizes(favicon_id, &bitmap_id_sizes);
 
   // If there is already a favicon bitmap of |pixel_size| at |icon_url|,
   // replace it.
   bool bitmap_identical = false;
   bool replaced_bitmap = false;
   for (size_t i = 0; i < bitmap_id_sizes.size(); ++i) {
@@ skipping 63 matching lines @@
   // Difficulty 1: All but news.google.com/news_specific.ico are unmapped from
   //              news.google.com
   // Difficulty 2: The favicon bitmaps for www.google.com/favicon.ico are not
   //               modified.
 
   std::vector<IconMapping> icon_mappings;
   thumbnail_db_->GetIconMappingsForPageURL(page_url, icon_type, &icon_mappings);
 
   // Copy the favicon bitmaps mapped to |page_url| to the favicon at |icon_url|
   // till the limit of |kMaxFaviconBitmapsPerIconURL| is reached.
+  bool favicon_bitmaps_copied = false;
   for (size_t i = 0; i < icon_mappings.size(); ++i) {
     if (favicon_sizes.size() >= kMaxFaviconBitmapsPerIconURL)
       break;
 
     if (icon_mappings[i].icon_url == icon_url)
       continue;
 
     std::vector<FaviconBitmap> bitmaps_to_copy;
     thumbnail_db_->GetFaviconBitmaps(icon_mappings[i].icon_id,
                                      &bitmaps_to_copy);
     for (size_t j = 0; j < bitmaps_to_copy.size(); ++j) {
       // Do not add a favicon bitmap at a pixel size for which there is already
       // a favicon bitmap mapped to |icon_url|. The one there is more correct
       // and having multiple equally sized favicon bitmaps for |page_url| is
       // ambiguous in terms of GetFaviconsForURL().
       std::vector<gfx::Size>::iterator it =
           std::find(favicon_sizes.begin(), favicon_sizes.end(),
                     bitmaps_to_copy[j].pixel_size);
       if (it != favicon_sizes.end())
         continue;
 
       // Add the favicon bitmap as expired as it is not consistent with the
       // merged in data.
       thumbnail_db_->AddFaviconBitmap(
           favicon_id, bitmaps_to_copy[j].bitmap_data, base::Time(),
           bitmaps_to_copy[j].pixel_size);
       favicon_sizes.push_back(bitmaps_to_copy[j].pixel_size);
+      favicon_bitmaps_copied = true;
 
       if (favicon_sizes.size() >= kMaxFaviconBitmapsPerIconURL)
         break;
     }
   }
 
   // Update the favicon mappings such that only |icon_url| is mapped to
   // |page_url|.
   bool mapping_changed = false;
   if (icon_mappings.size() != 1 || icon_mappings[0].icon_url != icon_url) {
     std::vector<favicon_base::FaviconID> favicon_ids;
     favicon_ids.push_back(favicon_id);
     SetFaviconMappingsForPageAndRedirects(page_url, icon_type, favicon_ids);
     mapping_changed = true;
   }
 
-  if (mapping_changed || !bitmap_identical)
+  if (mapping_changed)
     SendFaviconChangedNotificationForPageAndRedirects(page_url);
+
+  if (!favicon_created && (!bitmap_identical || favicon_bitmaps_copied)) {
+    // If there was a favicon at |icon_url| prior to MergeFavicon() being
+    // called, there may be page URLs which also use the favicon at |icon_url|.
+    // Notify the UI that the favicon has changed for |icon_url|.
+    SendFaviconChangedNotificationForIconURL(icon_url);
+  }
+
   ScheduleCommit();
 }
 
 void HistoryBackend::SetFavicons(const GURL& page_url,
                                  favicon_base::IconType icon_type,
                                  const GURL& icon_url,
                                  const std::vector<SkBitmap>& bitmaps) {
   if (!thumbnail_db_ || !db_)
     return;
 
   DCHECK_GE(kMaxFaviconBitmapsPerIconURL, bitmaps.size());
 
-  // Track whether the method modifies or creates any favicon bitmaps, favicons
-  // or icon mappings.
-  bool data_modified = false;
-
   favicon_base::FaviconID icon_id =
       thumbnail_db_->GetFaviconIDForFaviconURL(icon_url, icon_type, nullptr);
 
+  bool favicon_created = false;
   if (!icon_id) {
     icon_id = thumbnail_db_->AddFavicon(icon_url, icon_type);
-    data_modified = true;
+    favicon_created = true;
   }
 
-  data_modified |= SetFaviconBitmaps(icon_id, bitmaps);
+  bool favicon_data_modified = SetFaviconBitmaps(icon_id, bitmaps);
 
   std::vector<favicon_base::FaviconID> icon_ids(1u, icon_id);
-  data_modified |=
+  bool mapping_changed =
       SetFaviconMappingsForPageAndRedirects(page_url, icon_type, icon_ids);
 
-  if (data_modified) {
-    // Send notification to the UI as an icon mapping, favicon, or favicon
-    // bitmap was changed by this function.
+  if (mapping_changed) {
+    // Notify the UI that this function changed an icon mapping.
     SendFaviconChangedNotificationForPageAndRedirects(page_url);
   }
+
+  if (favicon_data_modified && !favicon_created) {
+    // If there was a favicon at |icon_url| prior to SetFavicons() being called,
+    // there may be page URLs which also use the favicon at |icon_url|. Notify
+    // the UI that the favicon has changed for |icon_url|.
+    SendFaviconChangedNotificationForIconURL(icon_url);
+  }
   ScheduleCommit();
 }
 
 void HistoryBackend::SetFaviconsOutOfDateForPage(const GURL& page_url) {
   std::vector<IconMapping> icon_mappings;
 
   if (!thumbnail_db_ ||
       !thumbnail_db_->GetIconMappingsForPageURL(page_url, &icon_mappings))
     return;
 
   for (std::vector<IconMapping>::iterator m = icon_mappings.begin();
        m != icon_mappings.end(); ++m) {
     thumbnail_db_->SetFaviconOutOfDate(m->icon_id);
   }
   ScheduleCommit();
 }
 
 void HistoryBackend::SetImportedFavicons(
     const favicon_base::FaviconUsageDataList& favicon_usage) {
   if (!db_ || !thumbnail_db_)
     return;
 
   Time now = Time::Now();
 
   // Track all URLs that had their favicons set or updated.
-  std::set<GURL> favicons_changed;
+  std::vector<GURL> favicons_changed;
 
   for (size_t i = 0; i < favicon_usage.size(); i++) {
     favicon_base::FaviconID favicon_id =
         thumbnail_db_->GetFaviconIDForFaviconURL(
             favicon_usage[i].favicon_url, favicon_base::FAVICON, nullptr);
     if (!favicon_id) {
       // This favicon doesn't exist yet, so we create it using the given data.
       // TODO(pkotwicz): Pass in real pixel size.
       favicon_id = thumbnail_db_->AddFavicon(
           favicon_usage[i].favicon_url, favicon_base::FAVICON,
@@ skipping 13 matching lines @@
         // cleaned, we keep an entry in the db with 0 visits as long as that
         // url is bookmarked.
         if (history_client && history_client->IsBookmarked(*url)) {
           URLRow url_info(*url);
           url_info.set_visit_count(0);
           url_info.set_typed_count(0);
           url_info.set_last_visit(base::Time());
           url_info.set_hidden(false);
           db_->AddURL(url_info);
           thumbnail_db_->AddIconMapping(*url, favicon_id);
-          favicons_changed.insert(*url);
+          favicons_changed.push_back(*url);
         }
       } else {
         if (!thumbnail_db_->GetIconMappingsForPageURL(
                 *url, favicon_base::FAVICON, nullptr)) {
           // URL is present in history, update the favicon *only* if it is not
           // set already.
           thumbnail_db_->AddIconMapping(*url, favicon_id);
-          favicons_changed.insert(*url);
+          favicons_changed.push_back(*url);
         }
       }
     }
   }
 
   if (!favicons_changed.empty()) {
     // Send the notification about the changed favicon URLs.
-    NotifyFaviconChanged(favicons_changed);
+    NotifyFaviconsChanged(favicons_changed, std::vector<GURL>());
   }
 }
 
 void HistoryBackend::UpdateFaviconMappingsAndFetchImpl(
     const GURL* page_url,
     const std::vector<GURL>& icon_urls,
     int icon_types,
     const std::vector<int>& desired_sizes,
     std::vector<favicon_base::FaviconRawBitmapResult>* bitmap_results) {
   // If |page_url| is specified, |icon_types| must be either a single icon
@@ skipping 308 matching lines @@
     // No known redirects, construct mock redirect chain containing |page_url|.
     redirect_list->push_back(page_url);
   }
 }
 
 void HistoryBackend::SendFaviconChangedNotificationForPageAndRedirects(
     const GURL& page_url) {
   RedirectList redirect_list;
   GetCachedRecentRedirects(page_url, &redirect_list);
   if (!redirect_list.empty()) {
-    std::set<GURL> favicons_changed(redirect_list.begin(), redirect_list.end());
-    NotifyFaviconChanged(favicons_changed);
+    std::vector<GURL> favicons_changed(redirect_list.begin(),
+                                       redirect_list.end());
+    NotifyFaviconsChanged(favicons_changed, std::vector<GURL>());
   }
 }
 
+void HistoryBackend::SendFaviconChangedNotificationForIconURL(
+    const GURL& icon_url) {
+  NotifyFaviconsChanged(std::vector<GURL>(),
+                        std::vector<GURL>(1u, icon_url));
+}
+
 void HistoryBackend::Commit() {
   if (!db_)
     return;
 
 #if defined(OS_IOS)
   // Attempts to get the application running long enough to commit the database
   // transaction if it is currently being backgrounded.
   base::ios::ScopedCriticalAction scoped_critical_action;
 #endif
 
@@ skipping 262 matching lines @@
     scoped_ptr<HistoryDBTask> task,
     scoped_refptr<base::SingleThreadTaskRunner> origin_loop,
     const base::CancelableTaskTracker::IsCanceledCallback& is_canceled) {
   bool scheduled = !queued_history_db_tasks_.empty();
   queued_history_db_tasks_.push_back(
       new QueuedHistoryDBTask(task.Pass(), origin_loop, is_canceled));
   if (!scheduled)
     ProcessDBTaskImpl();
 }
 
-void HistoryBackend::NotifyFaviconChanged(const std::set<GURL>& urls) {
+void HistoryBackend::NotifyFaviconsChanged(const std::vector<GURL>& page_urls,
+                                           const std::vector<GURL>& icon_urls) {
   if (delegate_)
-    delegate_->NotifyFaviconChanged(urls);
+    delegate_->NotifyFaviconsChanged(page_urls, icon_urls);
 }
 
 void HistoryBackend::NotifyURLVisited(ui::PageTransition transition,
                                       const URLRow& row,
                                       const RedirectList& redirects,
                                       base::Time visit_time) {
   URLRow url_info(row);
   if (typed_url_syncable_service_.get())
     typed_url_syncable_service_->OnUrlVisited(transition, &url_info);
 
@@ skipping 178 matching lines @@
   return true;
 }
 
 HistoryClient* HistoryBackend::GetHistoryClient() {
   if (history_client_)
     history_client_->BlockUntilBookmarksLoaded();
   return history_client_;
 }
 
 }  // namespace history