Cleanup history favicon code

chrome/browser/history/history.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.
 
 // The history system runs on a background thread so that potentially slow
 // database operations don't delay the browser. This backend processing is
 // represented by HistoryBackend. The HistoryService's job is to dispatch to
 // that thread.
 //
 // Main thread                       History thread
@@ skipping 89 matching lines @@
 }
 
 void DerefDownloadId(
     const HistoryService::DownloadNextIdCallback& callback,
     int* id) {
   callback.Run(*id);
 }
 
 void RunWithFaviconResults(
     const FaviconService::FaviconResultsCallback& callback,
-    const HistoryBackend::FaviconResults* results) {
-  callback.Run(results->bitmap_results, results->size_map);
+    std::vector<history::FaviconBitmapResult>* bitmap_results) {
+  callback.Run(*bitmap_results);
 }
 
 // Extract history::URLRows into GURLs for VisitedLinkMaster.
 class URLIteratorFromURLRows : public VisitedLinkMaster::URLIterator {
  public:
   explicit URLIteratorFromURLRows(const history::URLRows& url_rows)
       : itr_(url_rows.begin()),
         end_(url_rows.end()) {
   }
 
@@ skipping 488 matching lines @@
 CancelableTaskTracker::TaskId HistoryService::GetFavicons(
     const std::vector<GURL>& icon_urls,
     int icon_types,
     int desired_size_in_dip,
     const std::vector<ui::ScaleFactor>& desired_scale_factors,
     const FaviconService::FaviconResultsCallback& callback,
     CancelableTaskTracker* tracker) {
   DCHECK(thread_checker_.CalledOnValidThread());
   LoadBackendIfNecessary();
 
-  HistoryBackend::FaviconResults* results =
-      new HistoryBackend::FaviconResults();
+  std::vector<history::FaviconBitmapResult>* results =
+      new std::vector<history::FaviconBitmapResult>();
   return tracker->PostTaskAndReply(
       thread_->message_loop_proxy(),
       FROM_HERE,
       base::Bind(&HistoryBackend::GetFavicons,
                  history_backend_.get(), icon_urls, icon_types,
                  desired_size_in_dip, desired_scale_factors, results),
       base::Bind(&RunWithFaviconResults, callback, base::Owned(results)));
 }
 
 CancelableTaskTracker::TaskId HistoryService::GetFaviconsForURL(
     const GURL& page_url,
     int icon_types,
     int desired_size_in_dip,
     const std::vector<ui::ScaleFactor>& desired_scale_factors,
     const FaviconService::FaviconResultsCallback& callback,
     CancelableTaskTracker* tracker) {
   DCHECK(thread_checker_.CalledOnValidThread());
   LoadBackendIfNecessary();
 
-  HistoryBackend::FaviconResults* results =
-      new HistoryBackend::FaviconResults();
+  std::vector<history::FaviconBitmapResult>* results =
+      new std::vector<history::FaviconBitmapResult>();
   return tracker->PostTaskAndReply(
       thread_->message_loop_proxy(),
       FROM_HERE,
       base::Bind(&HistoryBackend::GetFaviconsForURL,
                  history_backend_.get(), page_url, icon_types,
                  desired_size_in_dip, desired_scale_factors, results),
       base::Bind(&RunWithFaviconResults, callback, base::Owned(results)));
 }
 
 CancelableTaskTracker::TaskId HistoryService::GetFaviconForID(
     history::FaviconID favicon_id,
     int desired_size_in_dip,
     ui::ScaleFactor desired_scale_factor,
     const FaviconService::FaviconResultsCallback& callback,
     CancelableTaskTracker* tracker) {
   DCHECK(thread_checker_.CalledOnValidThread());
   LoadBackendIfNecessary();
 
-  HistoryBackend::FaviconResults* results =
-      new HistoryBackend::FaviconResults();
+  std::vector<history::FaviconBitmapResult>* results =
+      new std::vector<history::FaviconBitmapResult>();
   return tracker->PostTaskAndReply(
       thread_->message_loop_proxy(),
       FROM_HERE,
       base::Bind(&HistoryBackend::GetFaviconForID,
                  history_backend_.get(), favicon_id,
                  desired_size_in_dip, desired_scale_factor, results),
       base::Bind(&RunWithFaviconResults, callback, base::Owned(results)));
 }
 
 CancelableTaskTracker::TaskId HistoryService::UpdateFaviconMappingsAndFetch(
     const GURL& page_url,
     const std::vector<GURL>& icon_urls,
     int icon_types,
     int desired_size_in_dip,
     const std::vector<ui::ScaleFactor>& desired_scale_factors,
     const FaviconService::FaviconResultsCallback& callback,
     CancelableTaskTracker* tracker) {
   DCHECK(thread_checker_.CalledOnValidThread());
   LoadBackendIfNecessary();
 
-  HistoryBackend::FaviconResults* results =
-      new HistoryBackend::FaviconResults();
+  std::vector<history::FaviconBitmapResult>* results =
+      new std::vector<history::FaviconBitmapResult>();
   return tracker->PostTaskAndReply(
       thread_->message_loop_proxy(),
       FROM_HERE,
       base::Bind(&HistoryBackend::UpdateFaviconMappingsAndFetch,
                  history_backend_.get(), page_url, icon_urls, icon_types,
                  desired_size_in_dip, desired_scale_factors, results),
       base::Bind(&RunWithFaviconResults, callback, base::Owned(results)));
 }
 
 void HistoryService::MergeFavicon(
     const GURL& page_url,
     const GURL& icon_url,
     history::IconType icon_type,
     scoped_refptr<base::RefCountedMemory> bitmap_data,
     const gfx::Size& pixel_size) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!CanAddURL(page_url))
     return;
 
   ScheduleAndForget(PRIORITY_NORMAL, &HistoryBackend::MergeFavicon, page_url,
                     icon_url, icon_type, bitmap_data, pixel_size);
 }
 
 void HistoryService::SetFavicons(
     const GURL& page_url,
     history::IconType icon_type,
-    const std::vector<history::FaviconBitmapData>& favicon_bitmap_data,
-    const history::IconURLSizesMap& icon_url_sizes) {
+    const std::vector<history::FaviconBitmapData>& favicon_bitmap_data) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!CanAddURL(page_url))
     return;
 
   ScheduleAndForget(PRIORITY_NORMAL, &HistoryBackend::SetFavicons, page_url,
-      icon_type, favicon_bitmap_data, icon_url_sizes);
+      icon_type, favicon_bitmap_data);
 }
 
 void HistoryService::SetFaviconsOutOfDateForPage(const GURL& page_url) {
   DCHECK(thread_checker_.CalledOnValidThread());
   ScheduleAndForget(PRIORITY_NORMAL,
                     &HistoryBackend::SetFaviconsOutOfDateForPage, page_url);
 }
 
 void HistoryService::CloneFavicons(const GURL& old_page_url,
                                    const GURL& new_page_url) {
@@ skipping 637 matching lines @@
   }
 }
 
 void HistoryService::OnDeleteDirectiveProcessed(
     const sync_pb::HistoryDeleteDirectiveSpecifics& delete_directive) {
   DVLOG(1) << "Processed delete directive: "
            << DeleteDirectiveToString(delete_directive);
   // TODO(akalin): Keep track of which delete directives we've already
   // processed.
 }