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

components/history/core/browser/history_service.h

 // 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.
 
 #ifndef COMPONENTS_HISTORY_CORE_BROWSER_HISTORY_SERVICE_H_
 #define COMPONENTS_HISTORY_CORE_BROWSER_HISTORY_SERVICE_H_
 
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 440 matching lines @@
   void RemoveObserver(HistoryServiceObserver* observer);
 
   // Generic Stuff -------------------------------------------------------------
 
   // Schedules a HistoryDBTask for running on the history backend thread. See
   // HistoryDBTask for details on what this does. Takes ownership of |task|.
   virtual base::CancelableTaskTracker::TaskId ScheduleDBTask(
       scoped_ptr<HistoryDBTask> task,
       base::CancelableTaskTracker* tracker);
 
-  // This callback is invoked when favicon change for urls.
-  typedef base::Callback<void(const std::set<GURL>&)> OnFaviconChangedCallback;
+  // Callback for when favicon data changes. The first std::vector contains a

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

Is there a reason why these are vectors and not sets?

[pkotwicz, 2015/06/21 22:16:09]

I used std::vectors because we do not call std::set::find() on either of the
parameters and I think that std::vectors are slightly faster and slightly more
memory efficient than std::sets.

Regardless, I changed the code to use std::sets as you requested.

+  // list of page URLs for which the favicon data has changed. The second
+  // std::vector contains a list of icon URLs for which the favicon data has
+  // changed.
+  typedef base::Callback<void(const std::vector<GURL>&,
+                              const std::vector<GURL>&)>
+      OnFaviconsChangedCallback;
 
   // Add a callback to the list. The callback will remain registered until the
-  // returned Subscription is destroyed. This must occurs before HistoryService
-  // is destroyed.
-  scoped_ptr<base::CallbackList<void(const std::set<GURL>&)>::Subscription>
-  AddFaviconChangedCallback(const OnFaviconChangedCallback& callback)
+  // returned Subscription is destroyed. The Subscription must be destroyed
+  // before HistoryService is destroyed.
+  scoped_ptr<base::CallbackList<void(const std::vector<GURL>&,
+                                     const std::vector<GURL>&)>::Subscription>
+  AddFaviconsChangedCallback(const OnFaviconsChangedCallback& callback)
       WARN_UNUSED_RESULT;
 
   // Testing -------------------------------------------------------------------
 
   // Runs |flushed| after bouncing off the history thread.
   void FlushForTest(const base::Closure& flushed);
 
   // Designed for unit tests, this passes the given task on to the history
   // backend to be called once the history backend has terminated. This allows
   // callers to know when the history thread is complete and the database files
@@ skipping 294 matching lines @@
   // database is loaded to make it available.
   void SetInMemoryBackend(scoped_ptr<InMemoryHistoryBackend> mem_backend);
 
   // Called by our BackendDelegate when there is a problem reading the database.
   void NotifyProfileError(sql::InitStatus init_status);
 
   // Call to schedule a given task for running on the history thread with the
   // specified priority. The task will have ownership taken.
   void ScheduleTask(SchedulePriority priority, const base::Closure& task);
 
-  // Invokes all callback registered by AddFaviconChangedCallback.
-  void NotifyFaviconChanged(const std::set<GURL>& changed_favicons);
+  // Called when the favicons for the given page URLs (e.g.
+  // http://www.google.com) and the given icon URLs (e.g.
+  // http://www.google.com/favicon.ico) have changed.
+  void NotifyFaviconsChanged(const std::vector<GURL>& page_urls,
+                             const std::vector<GURL>& icon_urls);
 
   base::ThreadChecker thread_checker_;
 
   // The thread used by the history service to run complicated operations.
   // |thread_| is null once Cleanup() is called.
   base::Thread* thread_;
 
   // This class has most of the implementation and runs on the 'thread_'.
   // You MUST communicate with this class ONLY through the thread_'s
   // message_loop().
@@ skipping 14 matching lines @@
 
   // The history client, may be null when testing. The object should otherwise
   // outlive |HistoryService|.
   HistoryClient* history_client_;
 
   // Has the backend finished loading? The backend is loaded once Init has
   // completed.
   bool backend_loaded_;
 
   base::ObserverList<HistoryServiceObserver> observers_;
-  base::CallbackList<void(const std::set<GURL>&)>
+  base::CallbackList<void(const std::vector<GURL>&, const std::vector<GURL>&)>
       favicon_changed_callback_list_;
 
   DeleteDirectiveHandler delete_directive_handler_;
 
   // All vended weak pointers are invalidated in Cleanup().
   base::WeakPtrFactory<HistoryService> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(HistoryService);
 };
 
 }  // namespace history
 
 #endif  // COMPONENTS_HISTORY_CORE_BROWSER_HISTORY_SERVICE_H_