Cleanup history favicon code

chrome/browser/history/history_backend_unittest.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 <algorithm>
 #include <set>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 1269 matching lines @@
   backend_->db_->AddURL(url_info2);
 
   history::RedirectList redirects;
   redirects.push_back(url2);
   redirects.push_back(url1);
   backend_->recent_redirects_.Put(url1, redirects);
 
   const GURL icon_url1("http://www.google.com/icon");
   const GURL icon_url2("http://www.google.com/icon2");
 
-  // Create mapping for a page with two favicons.
-  IconURLSizesMap two_icon_url_sizes;
-  two_icon_url_sizes[icon_url1] = GetSizesSmallAndLarge();
-  two_icon_url_sizes[icon_url2] = GetSizesSmallAndLarge();
+  // Generate bitmap data for a page with two favicons.
+  std::vector<FaviconBitmapData> two_favicon_bitmap_data;
+  GenerateFaviconBitmapData(icon_url1, GetSizesSmallAndLarge(),
+      icon_url2, GetSizesSmallAndLarge(), &two_favicon_bitmap_data);
 
-  // Create a mapping for a page with a single favicon.
-  IconURLSizesMap one_icon_url_sizes;
-  one_icon_url_sizes[icon_url1] = GetSizesSmallAndLarge();
-
-  std::vector<FaviconBitmapData> favicon_bitmap_data;
+  // Generate bitmap data for a page with a single favicon.
+  std::vector<FaviconBitmapData> one_favicon_bitmap_data;
+  GenerateFaviconBitmapData(icon_url1, GetSizesSmallAndLarge(),
+                            &one_favicon_bitmap_data);
 
   // Add two favicons
-  backend_->SetFavicons(url1, FAVICON, favicon_bitmap_data,
-      two_icon_url_sizes);
+  backend_->SetFavicons(url1, FAVICON, two_favicon_bitmap_data);
   EXPECT_EQ(2u, NumIconMappingsForPageURL(url1, FAVICON));
   EXPECT_EQ(2u, NumIconMappingsForPageURL(url2, FAVICON));
 
   // Add one touch_icon
-  backend_->SetFavicons(url1, TOUCH_ICON, favicon_bitmap_data,
-      one_icon_url_sizes);
+  backend_->SetFavicons(url1, TOUCH_ICON, one_favicon_bitmap_data);
   EXPECT_EQ(1u, NumIconMappingsForPageURL(url1, TOUCH_ICON));
   EXPECT_EQ(1u, NumIconMappingsForPageURL(url2, TOUCH_ICON));
   EXPECT_EQ(2u, NumIconMappingsForPageURL(url1, FAVICON));
 
   // Add one TOUCH_PRECOMPOSED_ICON
-  backend_->SetFavicons(url1, TOUCH_PRECOMPOSED_ICON, favicon_bitmap_data,
-      one_icon_url_sizes);
+  backend_->SetFavicons(url1, TOUCH_PRECOMPOSED_ICON, one_favicon_bitmap_data);
   // The touch_icon was replaced.
   EXPECT_EQ(0u, NumIconMappingsForPageURL(url1, TOUCH_ICON));
   EXPECT_EQ(2u, NumIconMappingsForPageURL(url1, FAVICON));
   EXPECT_EQ(1u, NumIconMappingsForPageURL(url1, TOUCH_PRECOMPOSED_ICON));
   EXPECT_EQ(1u, NumIconMappingsForPageURL(url2, TOUCH_PRECOMPOSED_ICON));
 
   // Add a touch_icon.
-  backend_->SetFavicons(url1, TOUCH_ICON, favicon_bitmap_data,
-      one_icon_url_sizes);
+  backend_->SetFavicons(url1, TOUCH_ICON, one_favicon_bitmap_data);
   EXPECT_EQ(1u, NumIconMappingsForPageURL(url1, TOUCH_ICON));
   EXPECT_EQ(2u, NumIconMappingsForPageURL(url1, FAVICON));
   // The TOUCH_PRECOMPOSED_ICON was replaced.
   EXPECT_EQ(0u, NumIconMappingsForPageURL(url1, TOUCH_PRECOMPOSED_ICON));
 
   // Add a single favicon.
-  backend_->SetFavicons(url1, FAVICON, favicon_bitmap_data,
-      one_icon_url_sizes);
+  backend_->SetFavicons(url1, FAVICON, one_favicon_bitmap_data);
   EXPECT_EQ(1u, NumIconMappingsForPageURL(url1, TOUCH_ICON));
   EXPECT_EQ(1u, NumIconMappingsForPageURL(url1, FAVICON));
   EXPECT_EQ(1u, NumIconMappingsForPageURL(url2, FAVICON));
 
   // Add two favicons.
-  backend_->SetFavicons(url1, FAVICON, favicon_bitmap_data,
-                        two_icon_url_sizes);
+  backend_->SetFavicons(url1, FAVICON, two_favicon_bitmap_data);
   EXPECT_EQ(1u, NumIconMappingsForPageURL(url1, TOUCH_ICON));
   EXPECT_EQ(2u, NumIconMappingsForPageURL(url1, FAVICON));
 }
 
 // Test that there is no churn in icon mappings from calling
-// SetFavicons() twice with the same |icon_url_sizes| parameter.
+// SetFavicons() twice with the same |favicon_bitmap_data| parameter.
 TEST_F(HistoryBackendTest, SetFaviconMappingsForPageDuplicates) {
   const GURL url("http://www.google.com/");
   const GURL icon_url("http://www.google.com/icon");
+
   std::vector<FaviconBitmapData> favicon_bitmap_data;
+  GenerateFaviconBitmapData(icon_url, GetSizesSmallAndLarge(),
+                            &favicon_bitmap_data);
 
-  IconURLSizesMap icon_url_sizes;
-  icon_url_sizes[icon_url] = GetSizesSmallAndLarge();
-
-  backend_->SetFavicons(url, FAVICON, favicon_bitmap_data, icon_url_sizes);
+  backend_->SetFavicons(url, FAVICON, favicon_bitmap_data);
 
   std::vector<IconMapping> icon_mappings;
   EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingsForPageURL(
       url, FAVICON, &icon_mappings));
   EXPECT_EQ(1u, icon_mappings.size());
   IconMappingID mapping_id = icon_mappings[0].mapping_id;
 
-  backend_->SetFavicons(url, FAVICON, favicon_bitmap_data, icon_url_sizes);
+  backend_->SetFavicons(url, FAVICON, favicon_bitmap_data);
 
   icon_mappings.clear();
   EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingsForPageURL(
       url, FAVICON, &icon_mappings));
   EXPECT_EQ(1u, icon_mappings.size());
 
   // The same row in the icon_mapping table should be used for the mapping as
   // before.
   EXPECT_EQ(mapping_id, icon_mappings[0].mapping_id);
 }
 
-// Test that setting favicons for a page which already has data does the
-// right thing.
-TEST_F(HistoryBackendTest, SetFavicons) {
-  const GURL page_url("http://www.google.com/");
-  std::vector<FaviconBitmapData> favicon_bitmap_data;
-  IconURLSizesMap icon_url_sizes;
-
-  // Set |page_url| as having two favicons each available from the web at two
-  // sizes.
-  const GURL icon_url1("http://www.google.com/icon1");
-  const GURL icon_url2("http://www.google.com/icon2");
-
-  icon_url_sizes[icon_url1] = GetSizesSmallAndLarge();
-  icon_url_sizes[icon_url2] = GetSizesSmallAndLarge();
-
-  // Set only sizes info for the favicons.
-  backend_->SetFavicons(page_url, FAVICON, favicon_bitmap_data,
-                        icon_url_sizes);
-
-  std::vector<IconMapping> icon_mappings;
-  EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingsForPageURL(
-      page_url, &icon_mappings));
-  EXPECT_EQ(2u, icon_mappings.size());
-  for (size_t i = 0; i < icon_mappings.size(); ++i) {
-    EXPECT_FALSE(backend_->thumbnail_db_->GetFaviconBitmaps(
-        icon_mappings[i].icon_id, NULL));
-  }
-
-  // Add bitmap data to the favicons.
-  GenerateFaviconBitmapData(icon_url1,
-                            GetSizesSmall(),
-                            icon_url2,
-                            GetSizesSmallAndLarge(),
-                            &favicon_bitmap_data);
-
-  backend_->SetFavicons(page_url, FAVICON, favicon_bitmap_data,
-                        icon_url_sizes);
-
-  icon_mappings.clear();
-  EXPECT_TRUE(GetSortedIconMappingsForPageURL(page_url, &icon_mappings));
-  EXPECT_EQ(2u, icon_mappings.size());
-
-  GURL icon_url;
-  IconType icon_type;
-  FaviconSizes favicon_sizes;
-  EXPECT_TRUE(backend_->thumbnail_db_->GetFaviconHeader(
-      icon_mappings[0].icon_id, &icon_url, &icon_type, &favicon_sizes));
-  EXPECT_EQ(icon_url1, icon_url);
-  EXPECT_EQ(FAVICON, icon_type);
-  EXPECT_EQ(GetSizesSmallAndLarge(), favicon_sizes);
-
-  std::vector<FaviconBitmap> favicon_bitmaps;
-  EXPECT_TRUE(backend_->thumbnail_db_->GetFaviconBitmaps(
-      icon_mappings[0].icon_id, &favicon_bitmaps));
-  EXPECT_EQ(1u, favicon_bitmaps.size());
-  EXPECT_TRUE(BitmapDataEqual('a', favicon_bitmaps[0].bitmap_data));
-  EXPECT_EQ(kSmallSize, favicon_bitmaps[0].pixel_size);
-
-  favicon_sizes.clear();
-  EXPECT_TRUE(backend_->thumbnail_db_->GetFaviconHeader(
-      icon_mappings[1].icon_id, &icon_url, &icon_type, &favicon_sizes));
-  EXPECT_EQ(icon_url2, icon_url);
-  EXPECT_EQ(FAVICON, icon_type);
-  EXPECT_EQ(GetSizesSmallAndLarge(), favicon_sizes);
-
-  favicon_bitmaps.clear();
-  EXPECT_TRUE(GetSortedFaviconBitmaps(icon_mappings[1].icon_id,
-                                      &favicon_bitmaps));
-
-  EXPECT_EQ(2u, favicon_bitmaps.size());
-  EXPECT_TRUE(BitmapDataEqual('b', favicon_bitmaps[0].bitmap_data));
-  EXPECT_EQ(kSmallSize, favicon_bitmaps[0].pixel_size);
-  EXPECT_TRUE(BitmapDataEqual('c', favicon_bitmaps[1].bitmap_data));
-  EXPECT_EQ(kLargeSize, favicon_bitmaps[1].pixel_size);
-
-  // Notifications should have been broadcast for each call to SetFavicons().
-  EXPECT_EQ(2, num_broadcasted_notifications());
-
-  // Change the sizes for which the favicon at icon_url1 is available at from
-  // the web. Verify that all the data remains valid.
-  icon_url_sizes[icon_url1] = GetSizesTinySmallAndLarge();
-  favicon_bitmap_data.clear();
-  backend_->SetFavicons(page_url, FAVICON, favicon_bitmap_data,
-                        icon_url_sizes);
-
-  icon_mappings.clear();
-  EXPECT_TRUE(GetSortedIconMappingsForPageURL(page_url, &icon_mappings));
-  EXPECT_EQ(2u, icon_mappings.size());
-
-  favicon_sizes.clear();
-  EXPECT_TRUE(backend_->thumbnail_db_->GetFaviconHeader(
-      icon_mappings[0].icon_id, &icon_url, &icon_type, &favicon_sizes));
-  EXPECT_EQ(icon_url1, icon_url);
-  EXPECT_EQ(FAVICON, icon_type);
-  EXPECT_EQ(GetSizesTinySmallAndLarge(), favicon_sizes);
-
-  favicon_bitmaps.clear();
-  EXPECT_TRUE(backend_->thumbnail_db_->GetFaviconBitmaps(
-      icon_mappings[0].icon_id, &favicon_bitmaps));
-  EXPECT_EQ(1u, favicon_bitmaps.size());
-
-  favicon_sizes.clear();
-  EXPECT_TRUE(backend_->thumbnail_db_->GetFaviconHeader(
-      icon_mappings[1].icon_id, &icon_url, &icon_type, &favicon_sizes));
-  EXPECT_EQ(icon_url2, icon_url);
-  EXPECT_EQ(FAVICON, icon_type);
-  EXPECT_EQ(GetSizesSmallAndLarge(), favicon_sizes);
-
-  favicon_bitmaps.clear();
-  EXPECT_TRUE(backend_->thumbnail_db_->GetFaviconBitmaps(
-      icon_mappings[1].icon_id, &favicon_bitmaps));
-  EXPECT_EQ(2u, favicon_bitmaps.size());
-
-  // No notifications should have been sent because changing the favicon sizes
-  // did not result in deleting any favicon bitmaps.
-  EXPECT_EQ(2, num_broadcasted_notifications());
-}
-
-// Test that changing the sizes that a favicon is available at from the web
-// deletes stale favicons and favicon bitmaps.
+// Test that calling SetFavicons() with FaviconBitmapData of different pixel
+// sizes than the initially passed in FaviconBitmapData deletes the no longer
+// used favicon bitmaps.
 TEST_F(HistoryBackendTest, SetFaviconsDeleteBitmaps) {
   const GURL page_url("http://www.google.com/");
   const GURL icon_url("http://www.google.com/icon");
 
-  // Set |page_url| as having one favicon with two different sizes.
-  IconURLSizesMap icon_url_sizes;
-  icon_url_sizes[icon_url] = GetSizesSmallAndLarge();
-
   std::vector<FaviconBitmapData> favicon_bitmap_data;
   GenerateFaviconBitmapData(icon_url, GetSizesSmallAndLarge(),
                             &favicon_bitmap_data);
+  backend_->SetFavicons(page_url, FAVICON, favicon_bitmap_data);
 
-  // Add bitmap data and sizes information to the database.
-  backend_->SetFavicons(page_url, FAVICON, favicon_bitmap_data,
-                        icon_url_sizes);
-
-  FaviconID favicon_id = backend_->thumbnail_db_->GetFaviconIDForFaviconURL(
-      icon_url, FAVICON, NULL);
-  EXPECT_NE(0, favicon_id);
+  // Test initial state.
+  std::vector<IconMapping> icon_mappings;
+  EXPECT_TRUE(GetSortedIconMappingsForPageURL(page_url, &icon_mappings));
+  EXPECT_EQ(1u, icon_mappings.size());
+  EXPECT_EQ(icon_url, icon_mappings[0].icon_url);
+  EXPECT_EQ(FAVICON, icon_mappings[0].icon_type);
+  FaviconID favicon_id = icon_mappings[0].icon_id;
 
   std::vector<FaviconBitmap> favicon_bitmaps;
-  EXPECT_TRUE(backend_->thumbnail_db_->GetFaviconBitmaps(favicon_id,
-                                                         &favicon_bitmaps));
+  EXPECT_TRUE(GetSortedFaviconBitmaps(favicon_id, &favicon_bitmaps));
   EXPECT_EQ(2u, favicon_bitmaps.size());
+  FaviconBitmapID small_bitmap_id = favicon_bitmaps[0].bitmap_id;
+  EXPECT_NE(0, small_bitmap_id);
+  EXPECT_TRUE(BitmapDataEqual('a', favicon_bitmaps[0].bitmap_data));
+  EXPECT_EQ(kSmallSize, favicon_bitmaps[0].pixel_size);
+  FaviconBitmapID large_bitmap_id = favicon_bitmaps[1].bitmap_id;
+  EXPECT_NE(0, large_bitmap_id);
+  EXPECT_TRUE(BitmapDataEqual('b', favicon_bitmaps[1].bitmap_data));
+  EXPECT_EQ(kLargeSize, favicon_bitmaps[1].pixel_size);
 
-  // Change the bitmap sizes available from the web only to the small size only.
-  icon_url_sizes[icon_url] = GetSizesSmall();
+  // Call SetFavicons() with bitmap data for only the large bitmap. Check that
+  // the small bitmap is in fact deleted.
+  GenerateFaviconBitmapData(icon_url, GetSizesLarge(), &favicon_bitmap_data);
+  backend_->SetFavicons(page_url, FAVICON, favicon_bitmap_data);
+
+  scoped_refptr<base::RefCountedMemory> bitmap_data_out;
+  gfx::Size pixel_size_out;
+  EXPECT_FALSE(backend_->thumbnail_db_->GetFaviconBitmap(small_bitmap_id,
+      NULL, &bitmap_data_out, &pixel_size_out));
+  EXPECT_TRUE(backend_->thumbnail_db_->GetFaviconBitmap(large_bitmap_id,
+      NULL, &bitmap_data_out, &pixel_size_out));
+  EXPECT_TRUE(BitmapDataEqual('a', bitmap_data_out));
+  EXPECT_EQ(kLargeSize, pixel_size_out);
+
+  icon_mappings.clear();
+  EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingsForPageURL(page_url,
+      &icon_mappings));
+  EXPECT_EQ(1u, icon_mappings.size());
+  EXPECT_EQ(favicon_id, icon_mappings[0].icon_id);
+
+  // Call SetFavicons() with no bitmap data. Check that the bitmaps and icon
+  // mappings are deleted.
   favicon_bitmap_data.clear();
-  backend_->SetFavicons(page_url, FAVICON, favicon_bitmap_data,
-                        icon_url_sizes);
+  backend_->SetFavicons(page_url, FAVICON, favicon_bitmap_data);
 
-  favicon_id = backend_->thumbnail_db_->GetFaviconIDForFaviconURL(
-      icon_url, FAVICON, NULL);
-  EXPECT_NE(0, favicon_id);
+  EXPECT_FALSE(backend_->thumbnail_db_->GetFaviconBitmap(large_bitmap_id, NULL,
+      NULL, NULL));
+  icon_mappings.clear();
+  EXPECT_FALSE(backend_->thumbnail_db_->GetIconMappingsForPageURL(page_url,
+      &icon_mappings));
 
-  favicon_bitmaps.clear();
-  EXPECT_TRUE(backend_->thumbnail_db_->GetFaviconBitmaps(favicon_id,
-                                                         &favicon_bitmaps));
-  EXPECT_EQ(1u, favicon_bitmaps.size());
-  EXPECT_EQ(kSmallSize, favicon_bitmaps[0].pixel_size);
-
-  // Clear |icon_url_sizes|. SetFavicons() should delete the remaining favicon
-  // and its favicon bitmap.
-  icon_url_sizes.clear();
-  backend_->SetFavicons(page_url, FAVICON, favicon_bitmap_data, icon_url_sizes);
-  EXPECT_EQ(0, backend_->thumbnail_db_->GetFaviconIDForFaviconURL(
-      icon_url, FAVICON, NULL));
-  EXPECT_FALSE(backend_->thumbnail_db_->GetFaviconBitmaps(favicon_id, NULL));
+  // Notifications should have been broadcast for each call to SetFavicons().
+  EXPECT_EQ(3, num_broadcasted_notifications());
 }
 
 // Test updating a single favicon bitmap's data via SetFavicons.
 TEST_F(HistoryBackendTest, SetFaviconsReplaceBitmapData) {
-
   const GURL page_url("http://www.google.com/");
   const GURL icon_url("http://www.google.com/icon");
-  IconURLSizesMap icon_url_sizes;
-  icon_url_sizes[icon_url] = GetSizesSmall();
 
   std::vector<unsigned char> data_initial;
   data_initial.push_back('a');
 
   FaviconBitmapData bitmap_data_element;
   bitmap_data_element.bitmap_data =
       base::RefCountedBytes::TakeVector(&data_initial);
   bitmap_data_element.pixel_size = kSmallSize;
   bitmap_data_element.icon_url = icon_url;
   std::vector<FaviconBitmapData> favicon_bitmap_data;
   favicon_bitmap_data.push_back(bitmap_data_element);
 
   // Add bitmap to the database.
-  backend_->SetFavicons(page_url, FAVICON, favicon_bitmap_data,
-                        icon_url_sizes);
+  backend_->SetFavicons(page_url, FAVICON, favicon_bitmap_data);
 
   FaviconID original_favicon_id =
       backend_->thumbnail_db_->GetFaviconIDForFaviconURL(icon_url, FAVICON,
                                                          NULL);
   EXPECT_NE(0, original_favicon_id);
   FaviconBitmap original_favicon_bitmap;
   EXPECT_TRUE(
       GetOnlyFaviconBitmap(original_favicon_id, &original_favicon_bitmap));
   EXPECT_TRUE(BitmapDataEqual('a', original_favicon_bitmap.bitmap_data));
 
   EXPECT_EQ(1, num_broadcasted_notifications());
 
   // Call SetFavicons() with completely identical data.
   std::vector<unsigned char> updated_data;
   updated_data.push_back('a');
   favicon_bitmap_data[0].bitmap_data = new base::RefCountedBytes(updated_data);
-  backend_->SetFavicons(page_url, FAVICON, favicon_bitmap_data,
-                        icon_url_sizes);
+  backend_->SetFavicons(page_url, FAVICON, favicon_bitmap_data);
 
   FaviconID updated_favicon_id =
       backend_->thumbnail_db_->GetFaviconIDForFaviconURL(icon_url, FAVICON,
                                                          NULL);
   EXPECT_NE(0, updated_favicon_id);
   FaviconBitmap updated_favicon_bitmap;
   EXPECT_TRUE(
       GetOnlyFaviconBitmap(updated_favicon_id, &updated_favicon_bitmap));
   EXPECT_TRUE(BitmapDataEqual('a', updated_favicon_bitmap.bitmap_data));
 
   // Because the bitmap data is byte equivalent, no notifications should have
   // been broadcasted.
   EXPECT_EQ(1, num_broadcasted_notifications());
 
   // Call SetFavicons() with identical data but a different bitmap.
   updated_data[0] = 'b';
   favicon_bitmap_data[0].bitmap_data = new base::RefCountedBytes(updated_data);
-  backend_->SetFavicons(page_url, FAVICON, favicon_bitmap_data,
-                        icon_url_sizes);
+  backend_->SetFavicons(page_url, FAVICON, favicon_bitmap_data);
 
   updated_favicon_id =
       backend_->thumbnail_db_->GetFaviconIDForFaviconURL(icon_url, FAVICON,
                                                          NULL);
   EXPECT_NE(0, updated_favicon_id);
   EXPECT_TRUE(
       GetOnlyFaviconBitmap(updated_favicon_id, &updated_favicon_bitmap));
   EXPECT_TRUE(BitmapDataEqual('b', updated_favicon_bitmap.bitmap_data));
 
   // There should be no churn in FaviconIDs or FaviconBitmapIds even though
   // the bitmap data changed.
   EXPECT_EQ(original_favicon_bitmap.icon_id, updated_favicon_bitmap.icon_id);
   EXPECT_EQ(original_favicon_bitmap.bitmap_id,
             updated_favicon_bitmap.bitmap_id);
 
   // A notification should have been broadcasted as the favicon bitmap data has
   // changed.
   EXPECT_EQ(2, num_broadcasted_notifications());
 }
 
 // Test that if two pages share the same FaviconID, changing the favicon for
 // one page does not affect the other.
 TEST_F(HistoryBackendTest, SetFaviconsSameFaviconURLForTwoPages) {
   GURL icon_url("http://www.google.com/favicon.ico");
   GURL icon_url_new("http://www.google.com/favicon2.ico");
   GURL page_url1("http://www.google.com");
   GURL page_url2("http://www.google.ca");
 
-  IconURLSizesMap icon_url_sizes;
-  icon_url_sizes[icon_url] = GetSizesSmallAndLarge();
-
   std::vector<FaviconBitmapData> favicon_bitmap_data;
   GenerateFaviconBitmapData(icon_url, GetSizesSmallAndLarge(),
                             &favicon_bitmap_data);
 
-  backend_->SetFavicons(page_url1, FAVICON, favicon_bitmap_data,
-                        icon_url_sizes);
+  backend_->SetFavicons(page_url1, FAVICON, favicon_bitmap_data);
 
   std::vector<GURL> icon_urls;
   icon_urls.push_back(icon_url);
 
-  HistoryBackend::FaviconResults results;
+  std::vector<FaviconBitmapResult> bitmap_results;
   backend_->UpdateFaviconMappingsAndFetch(
       page_url2, icon_urls, FAVICON, kSmallSize.width(),
-      GetScaleFactors1x2x(), &results);
+      GetScaleFactors1x2x(), &bitmap_results);
 
   // Check that the same FaviconID is mapped to both page URLs.
   std::vector<IconMapping> icon_mappings;
   EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingsForPageURL(
       page_url1, &icon_mappings));
   EXPECT_EQ(1u, icon_mappings.size());
   FaviconID favicon_id = icon_mappings[0].icon_id;
   EXPECT_NE(0, favicon_id);
 
   icon_mappings.clear();
   EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingsForPageURL(
       page_url2, &icon_mappings));
   EXPECT_EQ(1u, icon_mappings.size());
   EXPECT_EQ(favicon_id, icon_mappings[0].icon_id);
 
   // Change the icon URL that |page_url1| is mapped to.
-  icon_url_sizes.clear();
-  icon_url_sizes[icon_url_new] = GetSizesSmall();
   GenerateFaviconBitmapData(icon_url_new, GetSizesSmall(),
                             &favicon_bitmap_data);
-  backend_->SetFavicons(page_url1, FAVICON, favicon_bitmap_data,
-                        icon_url_sizes);
+  backend_->SetFavicons(page_url1, FAVICON, favicon_bitmap_data);
 
   // |page_url1| should map to a new FaviconID and have valid bitmap data.
   icon_mappings.clear();
   EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingsForPageURL(
       page_url1, &icon_mappings));
   EXPECT_EQ(1u, icon_mappings.size());
   EXPECT_EQ(icon_url_new, icon_mappings[0].icon_url);
   EXPECT_NE(favicon_id, icon_mappings[0].icon_id);
 
   std::vector<FaviconBitmap> favicon_bitmaps;
@@ skipping 12 matching lines @@
   favicon_bitmaps.clear();
   EXPECT_TRUE(backend_->thumbnail_db_->GetFaviconBitmaps(favicon_id,
                                                          &favicon_bitmaps));
   EXPECT_EQ(2u, favicon_bitmaps.size());
 
   // A notification should have been broadcast for each call to SetFavicons()
   // and each call to UpdateFaviconMappingsAndFetch().
   EXPECT_EQ(3, num_broadcasted_notifications());
 }
 
-// Test that there is no churn from calling UpdateFaviconMappingsAndFetch()
-// for an icon URL which is already mapped to the passed in page URL.
+// Test that no notifications are broadcast as a result of calling
+// UpdateFaviconMappingsAndFetch() for an icon URL which is already
+// mapped to the passed in page URL.
 TEST_F(HistoryBackendTest, UpdateFaviconMappingsAndFetchNoChange) {
   GURL page_url("http://www.google.com");
   GURL icon_url("http://www.google.com/favicon.ico");
   std::vector<FaviconBitmapData> favicon_bitmap_data;
+  GenerateFaviconBitmapData(icon_url, GetSizesSmall(), &favicon_bitmap_data);
 
-  IconURLSizesMap icon_url_sizes;
-  icon_url_sizes[icon_url] = GetSizesSmall();
-
-  backend_->SetFavicons(page_url, FAVICON, favicon_bitmap_data,
-                        icon_url_sizes);
+  backend_->SetFavicons(page_url, FAVICON, favicon_bitmap_data);
 
   FaviconID icon_id = backend_->thumbnail_db_->GetFaviconIDForFaviconURL(
       icon_url, FAVICON, NULL);
   EXPECT_NE(0, icon_id);
   EXPECT_EQ(1, num_broadcasted_notifications());
 
   std::vector<GURL> icon_urls;
   icon_urls.push_back(icon_url);
 
-  HistoryBackend::FaviconResults results;
+  std::vector<FaviconBitmapResult> bitmap_results;
   backend_->UpdateFaviconMappingsAndFetch(
       page_url, icon_urls, FAVICON, kSmallSize.width(),
-      GetScaleFactors1x2x(), &results);
+      GetScaleFactors1x2x(), &bitmap_results);
 
   EXPECT_EQ(icon_id, backend_->thumbnail_db_->GetFaviconIDForFaviconURL(
       icon_url, FAVICON, NULL));
 
   // No notification should have been broadcast as no icon mapping, favicon,
   // or favicon bitmap was updated, added or removed.
   EXPECT_EQ(1, num_broadcasted_notifications());
 }
 
 // Test repeatedly calling MergeFavicon(). |page_url| is initially not known
 // to the database.
 TEST_F(HistoryBackendTest, MergeFaviconPageURLNotInDB) {
   GURL page_url("http://www.google.com");
   GURL icon_url("http:/www.google.com/favicon.ico");
 
   std::vector<unsigned char> data;
   data.push_back('a');
   scoped_refptr<base::RefCountedBytes> bitmap_data(
       new base::RefCountedBytes(data));
 
   backend_->MergeFavicon(page_url, icon_url, FAVICON, bitmap_data, kSmallSize);
 
-  // |page_url| should now be mapped to |icon_url| and sizes should be set
-  // to GetDefaultFaviconSizes().
+  // |page_url| should now be mapped to |icon_url| and the favicon bitmap should
+  // not be expired.
   std::vector<IconMapping> icon_mappings;
   EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingsForPageURL(page_url,
       &icon_mappings));
   EXPECT_EQ(1u, icon_mappings.size());
   EXPECT_EQ(icon_url, icon_mappings[0].icon_url);
 
-  FaviconSizes favicon_sizes;
-  EXPECT_TRUE(backend_->thumbnail_db_->GetFaviconHeader(
-      icon_mappings[0].icon_id, NULL, NULL, &favicon_sizes));
-  EXPECT_EQ(GetDefaultFaviconSizes(), favicon_sizes);
-
   FaviconBitmap favicon_bitmap;
   EXPECT_TRUE(GetOnlyFaviconBitmap(icon_mappings[0].icon_id, &favicon_bitmap));
+  EXPECT_NE(base::Time(), favicon_bitmap.last_updated);
   EXPECT_TRUE(BitmapDataEqual('a', favicon_bitmap.bitmap_data));
   EXPECT_EQ(kSmallSize, favicon_bitmap.pixel_size);
 
   data[0] = 'b';
   bitmap_data = new base::RefCountedBytes(data);
   backend_->MergeFavicon(page_url, icon_url, FAVICON, bitmap_data, kSmallSize);
 
   // |page_url| should still have a single favicon bitmap. The bitmap data
   // should be updated.
   icon_mappings.clear();
   EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingsForPageURL(page_url,
       &icon_mappings));
   EXPECT_EQ(1u, icon_mappings.size());
   EXPECT_EQ(icon_url, icon_mappings[0].icon_url);
 
-  favicon_sizes.clear();
-  EXPECT_TRUE(backend_->thumbnail_db_->GetFaviconHeader(
-      icon_mappings[0].icon_id, NULL, NULL, &favicon_sizes));
-  EXPECT_EQ(GetDefaultFaviconSizes(), favicon_sizes);
-
   EXPECT_TRUE(GetOnlyFaviconBitmap(icon_mappings[0].icon_id, &favicon_bitmap));
+  EXPECT_NE(base::Time(), favicon_bitmap.last_updated);
   EXPECT_TRUE(BitmapDataEqual('b', favicon_bitmap.bitmap_data));
   EXPECT_EQ(kSmallSize, favicon_bitmap.pixel_size);
 }
 
 // Test calling MergeFavicon() when |page_url| is known to the database.
 TEST_F(HistoryBackendTest, MergeFaviconPageURLInDB) {
   GURL page_url("http://www.google.com");
   GURL icon_url1("http:/www.google.com/favicon.ico");
   GURL icon_url2("http://www.google.com/favicon2.ico");
 
-  IconURLSizesMap icon_url_sizes;
-  icon_url_sizes[icon_url1] = GetSizesSmallAndLarge();
-
   std::vector<FaviconBitmapData> favicon_bitmap_data;
   GenerateFaviconBitmapData(icon_url1, GetSizesSmall(),
                             &favicon_bitmap_data);
 
-  backend_->SetFavicons(page_url, FAVICON, favicon_bitmap_data,
-                        icon_url_sizes);
+  backend_->SetFavicons(page_url, FAVICON, favicon_bitmap_data);
 
   // Test initial state.
   std::vector<IconMapping> icon_mappings;
   EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingsForPageURL(page_url,
       &icon_mappings));
   EXPECT_EQ(1u, icon_mappings.size());
   EXPECT_EQ(icon_url1, icon_mappings[0].icon_url);
 
-  FaviconSizes favicon_sizes;
-  EXPECT_TRUE(backend_->thumbnail_db_->GetFaviconHeader(
-      icon_mappings[0].icon_id, NULL, NULL, &favicon_sizes));
-  EXPECT_EQ(GetSizesSmallAndLarge(), favicon_sizes);
-
   FaviconBitmap favicon_bitmap;
   EXPECT_TRUE(GetOnlyFaviconBitmap(icon_mappings[0].icon_id, &favicon_bitmap));
+  EXPECT_NE(base::Time(), favicon_bitmap.last_updated);
   EXPECT_TRUE(BitmapDataEqual('a', favicon_bitmap.bitmap_data));
   EXPECT_EQ(kSmallSize, favicon_bitmap.pixel_size);
 
   EXPECT_EQ(1, num_broadcasted_notifications());
 
   // 1) Merge identical favicon bitmap.
   std::vector<unsigned char> data;
   data.push_back('a');
   scoped_refptr<base::RefCountedBytes> bitmap_data(
       new base::RefCountedBytes(data));
   backend_->MergeFavicon(page_url, icon_url1, FAVICON, bitmap_data, kSmallSize);
 
   // All the data should stay the same and no notifications should have been
   // sent.
   icon_mappings.clear();
   EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingsForPageURL(page_url,
       &icon_mappings));
   EXPECT_EQ(1u, icon_mappings.size());
   EXPECT_EQ(icon_url1, icon_mappings[0].icon_url);
 
-  favicon_sizes.clear();
-  EXPECT_TRUE(backend_->thumbnail_db_->GetFaviconHeader(
-      icon_mappings[0].icon_id, NULL, NULL, &favicon_sizes));
-  EXPECT_EQ(GetSizesSmallAndLarge(), favicon_sizes);
-
   EXPECT_TRUE(GetOnlyFaviconBitmap(icon_mappings[0].icon_id, &favicon_bitmap));
+  EXPECT_NE(base::Time(), favicon_bitmap.last_updated);
   EXPECT_TRUE(BitmapDataEqual('a', favicon_bitmap.bitmap_data));
   EXPECT_EQ(kSmallSize, favicon_bitmap.pixel_size);
 
   EXPECT_EQ(1, num_broadcasted_notifications());
 
   // 2) Merge favicon bitmap of the same size.
   data[0] = 'b';
   bitmap_data = new base::RefCountedBytes(data);
   backend_->MergeFavicon(page_url, icon_url1, FAVICON, bitmap_data, kSmallSize);
 
   // The small favicon bitmap at |icon_url1| should be overwritten and favicon
   // sizes should remain unchanged. No notification should be sent.
   icon_mappings.clear();
   EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingsForPageURL(page_url,
       &icon_mappings));
   EXPECT_EQ(1u, icon_mappings.size());
   EXPECT_EQ(icon_url1, icon_mappings[0].icon_url);
 
-  favicon_sizes.clear();
-  EXPECT_TRUE(backend_->thumbnail_db_->GetFaviconHeader(
-      icon_mappings[0].icon_id, NULL, NULL, &favicon_sizes));
-  EXPECT_EQ(GetSizesSmallAndLarge(), favicon_sizes);
-
   EXPECT_TRUE(GetOnlyFaviconBitmap(icon_mappings[0].icon_id, &favicon_bitmap));
+  EXPECT_NE(base::Time(), favicon_bitmap.last_updated);
   EXPECT_TRUE(BitmapDataEqual('b', favicon_bitmap.bitmap_data));
   EXPECT_EQ(kSmallSize, favicon_bitmap.pixel_size);
 
   EXPECT_EQ(1, num_broadcasted_notifications());
 
   // 3) Merge favicon for the same icon URL, but a pixel size for which there is
   // no favicon bitmap.
   data[0] = 'c';
   bitmap_data = new base::RefCountedBytes(data);
   backend_->MergeFavicon(page_url, icon_url1, FAVICON, bitmap_data, kTinySize);
 
-  // A new favicon bitmap should be created and favicon sizes should be set to
-  // the default.
+  // A new favicon bitmap should be created and the preexisting favicon bitmap
+  // ('b') should be expired.
   icon_mappings.clear();
   EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingsForPageURL(page_url,
       &icon_mappings));
   EXPECT_EQ(1u, icon_mappings.size());
   EXPECT_EQ(icon_url1, icon_mappings[0].icon_url);
 
-  favicon_sizes.clear();
-  EXPECT_TRUE(backend_->thumbnail_db_->GetFaviconHeader(
-      icon_mappings[0].icon_id, NULL, NULL, &favicon_sizes));
-  EXPECT_EQ(GetDefaultFaviconSizes(), favicon_sizes);
-
   std::vector<FaviconBitmap> favicon_bitmaps;
   EXPECT_TRUE(GetSortedFaviconBitmaps(icon_mappings[0].icon_id,
                                       &favicon_bitmaps));
+  EXPECT_NE(base::Time(), favicon_bitmaps[0].last_updated);
   EXPECT_TRUE(BitmapDataEqual('c', favicon_bitmaps[0].bitmap_data));
   EXPECT_EQ(kTinySize, favicon_bitmaps[0].pixel_size);
+  EXPECT_EQ(base::Time(), favicon_bitmaps[1].last_updated);
   EXPECT_TRUE(BitmapDataEqual('b', favicon_bitmaps[1].bitmap_data));
   EXPECT_EQ(kSmallSize, favicon_bitmaps[1].pixel_size);
 
   // 4) Merge favicon for an icon URL different from the icon URLs already
   // mapped to page URL.
   data[0] = 'd';
   bitmap_data = new base::RefCountedBytes(data);
   backend_->MergeFavicon(page_url, icon_url2, FAVICON, bitmap_data, kSmallSize);
 
   // The existing favicon bitmaps should be copied over to the newly created
   // favicon at |icon_url2|. |page_url| should solely be mapped to |icon_url2|.
   icon_mappings.clear();
   EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingsForPageURL(page_url,
       &icon_mappings));
   EXPECT_EQ(1u, icon_mappings.size());
   EXPECT_EQ(icon_url2, icon_mappings[0].icon_url);
 
-  favicon_sizes.clear();
-  EXPECT_TRUE(backend_->thumbnail_db_->GetFaviconHeader(
-      icon_mappings[0].icon_id, NULL, NULL, &favicon_sizes));
-  EXPECT_EQ(GetDefaultFaviconSizes(), favicon_sizes);
-
   favicon_bitmaps.clear();
   EXPECT_TRUE(GetSortedFaviconBitmaps(icon_mappings[0].icon_id,
                                       &favicon_bitmaps));
+  EXPECT_EQ(base::Time(), favicon_bitmaps[0].last_updated);
   EXPECT_TRUE(BitmapDataEqual('c', favicon_bitmaps[0].bitmap_data));
   EXPECT_EQ(kTinySize, favicon_bitmaps[0].pixel_size);
   // The favicon being merged should take precedence over the preexisting
   // favicon bitmaps.
+  EXPECT_NE(base::Time(), favicon_bitmaps[1].last_updated);
   EXPECT_TRUE(BitmapDataEqual('d', favicon_bitmaps[1].bitmap_data));
   EXPECT_EQ(kSmallSize, favicon_bitmaps[1].pixel_size);
 
   // A notification should have been broadcast for each call to SetFavicons()
   // and MergeFavicon().
   EXPECT_EQ(3, num_broadcasted_notifications());
 }
 
 // Test calling MergeFavicon() when |icon_url| is known to the database but not
 // mapped to |page_url|.
 TEST_F(HistoryBackendTest, MergeFaviconIconURLMappedToDifferentPageURL) {
   GURL page_url1("http://www.google.com");
   GURL page_url2("http://news.google.com");
   GURL icon_url("http:/www.google.com/favicon.ico");
 
-  IconURLSizesMap icon_url_sizes;
-  icon_url_sizes[icon_url] = GetSizesSmallAndLarge();
-
   std::vector<FaviconBitmapData> favicon_bitmap_data;
   GenerateFaviconBitmapData(icon_url, GetSizesSmall(),
                             &favicon_bitmap_data);
 
-  backend_->SetFavicons(page_url1, FAVICON, favicon_bitmap_data,
-                        icon_url_sizes);
+  backend_->SetFavicons(page_url1, FAVICON, favicon_bitmap_data);
 
   // Test initial state.
   std::vector<IconMapping> icon_mappings;
   EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingsForPageURL(page_url1,
       &icon_mappings));
   EXPECT_EQ(1u, icon_mappings.size());
   EXPECT_EQ(icon_url, icon_mappings[0].icon_url);
 
-  FaviconSizes favicon_sizes;
-  EXPECT_TRUE(backend_->thumbnail_db_->GetFaviconHeader(
-      icon_mappings[0].icon_id, NULL, NULL, &favicon_sizes));
-  EXPECT_EQ(GetSizesSmallAndLarge(), favicon_sizes);
-
   FaviconBitmap favicon_bitmap;
   EXPECT_TRUE(GetOnlyFaviconBitmap(icon_mappings[0].icon_id, &favicon_bitmap));
+  EXPECT_NE(base::Time(), favicon_bitmap.last_updated);
   EXPECT_TRUE(BitmapDataEqual('a', favicon_bitmap.bitmap_data));
   EXPECT_EQ(kSmallSize, favicon_bitmap.pixel_size);
 
   std::vector<unsigned char> data;
   data.push_back('b');
   scoped_refptr<base::RefCountedBytes> bitmap_data(
       new base::RefCountedBytes(data));
   backend_->MergeFavicon(page_url2, icon_url, FAVICON, bitmap_data, kSmallSize);
 
   // The small favicon bitmap at |icon_url| should be overwritten. |page_url1|
@@ skipping 10 matching lines @@
       &icon_mappings));
   EXPECT_EQ(1u, icon_mappings.size());
   EXPECT_EQ(favicon_id, icon_mappings[0].icon_id);
 
   GURL icon_url_in_db;
   EXPECT_TRUE(backend_->thumbnail_db_->GetFaviconHeader(
       icon_mappings[0].icon_id, &icon_url_in_db, NULL, NULL));
   EXPECT_EQ(icon_url, icon_url_in_db);
 
   EXPECT_TRUE(GetOnlyFaviconBitmap(favicon_id, &favicon_bitmap));
+  EXPECT_NE(base::Time(), favicon_bitmap.last_updated);
   EXPECT_TRUE(BitmapDataEqual('b', favicon_bitmap.bitmap_data));
   EXPECT_EQ(kSmallSize, favicon_bitmap.pixel_size);
 }
 
 // Test that MergeFavicon() does not add more than
 // |kMaxFaviconBitmapsPerIconURL| to a favicon.
 TEST_F(HistoryBackendTest, MergeFaviconMaxFaviconBitmapsPerIconURL) {
   GURL page_url("http://www.google.com");
   std::string icon_url_string("http://www.google.com/favicon.ico");
   size_t replace_index = icon_url_string.size() - 1;
@@ skipping 25 matching lines @@
   EXPECT_EQ(kMaxFaviconBitmapsPerIconURL, favicon_bitmaps.size());
 }
 
 // Tests that the favicon set by MergeFavicon() shows up in the result of
 // GetFaviconsForURL().
 TEST_F(HistoryBackendTest, MergeFaviconShowsUpInGetFaviconsForURLResult) {
   GURL page_url("http://www.google.com");
   GURL icon_url("http://www.google.com/favicon.ico");
   GURL merged_icon_url("http://wwww.google.com/favicon2.ico");
 
-  IconURLSizesMap icon_url_sizes;
-  icon_url_sizes[icon_url] = GetSizesSmallAndLarge();
-
   std::vector<FaviconBitmapData> favicon_bitmap_data;
   GenerateFaviconBitmapData(icon_url, GetSizesSmallAndLarge(),
                             &favicon_bitmap_data);
 
   // Set some preexisting favicons for |page_url|.
-  backend_->SetFavicons(page_url, FAVICON, favicon_bitmap_data,
-                        icon_url_sizes);
+  backend_->SetFavicons(page_url, FAVICON, favicon_bitmap_data);
 
   // Merge small favicon.
   std::vector<unsigned char> data;
   data.push_back('c');
   scoped_refptr<base::RefCountedBytes> bitmap_data(
       new base::RefCountedBytes(data));
   backend_->MergeFavicon(page_url, merged_icon_url, FAVICON, bitmap_data,
                          kSmallSize);
 
   // Request favicon bitmaps for both 1x and 2x to simulate request done by
   // BookmarkModel::GetFavicon().
-  HistoryBackend::FaviconResults results;
+  std::vector<FaviconBitmapResult> bitmap_results;
   backend_->GetFaviconsForURL(page_url, FAVICON, kSmallSize.width(),
-                              GetScaleFactors1x2x(), &results);
+                              GetScaleFactors1x2x(), &bitmap_results);
 
-  EXPECT_EQ(2u, results.bitmap_results.size());
-  const FaviconBitmapResult& first_result = results.bitmap_results[0];
+  EXPECT_EQ(2u, bitmap_results.size());
+  const FaviconBitmapResult& first_result = bitmap_results[0];
   const FaviconBitmapResult& result =
       (first_result.pixel_size == kSmallSize) ? first_result
-                                              : results.bitmap_results[1];
+                                              : bitmap_results[1];
   EXPECT_TRUE(BitmapDataEqual('c', result.bitmap_data));
 }
 
 // Test UpdateFaviconMapingsAndFetch() when multiple icon types are passed in.
 TEST_F(HistoryBackendTest, UpdateFaviconMappingsAndFetchMultipleIconTypes) {
   GURL page_url1("http://www.google.com");
   GURL page_url2("http://news.google.com");
   GURL page_url3("http://mail.google.com");
   GURL icon_urla("http://www.google.com/favicon1.ico");
   GURL icon_urlb("http://www.google.com/favicon2.ico");
   GURL icon_urlc("http://www.google.com/favicon3.ico");
 
   // |page_url1| is mapped to |icon_urla| which if of type TOUCH_ICON.
-  IconURLSizesMap icon_url_sizes;
-  icon_url_sizes[icon_urla] = GetSizesSmall();
-
   std::vector<FaviconBitmapData> favicon_bitmap_data;
   GenerateFaviconBitmapData(icon_urla, GetSizesSmall(), &favicon_bitmap_data);
-  backend_->SetFavicons(page_url1, TOUCH_ICON, favicon_bitmap_data,
-                        icon_url_sizes);
+  backend_->SetFavicons(page_url1, TOUCH_ICON, favicon_bitmap_data);
 
   // |page_url2| is mapped to |icon_urlb| and |icon_urlc| which are of type
   // TOUCH_PRECOMPOSED_ICON.
-  icon_url_sizes.clear();
-  icon_url_sizes[icon_urlb] = GetSizesSmall();
-  icon_url_sizes[icon_urlc] = GetSizesSmall();
   GenerateFaviconBitmapData(icon_urlb, GetSizesSmall(), icon_urlc,
                             GetSizesSmall(), &favicon_bitmap_data);
-  backend_->SetFavicons(page_url2, TOUCH_PRECOMPOSED_ICON, favicon_bitmap_data,
-                        icon_url_sizes);
+  backend_->SetFavicons(page_url2, TOUCH_PRECOMPOSED_ICON, favicon_bitmap_data);
 
   std::vector<GURL> icon_urls;
   icon_urls.push_back(icon_urla);
   icon_urls.push_back(icon_urlb);
   icon_urls.push_back(icon_urlc);
 
-  HistoryBackend::FaviconResults results;
+  std::vector<FaviconBitmapResult> bitmap_results;
   backend_->UpdateFaviconMappingsAndFetch(
       page_url3, icon_urls, (TOUCH_ICON | TOUCH_PRECOMPOSED_ICON),
-      kSmallSize.width(), GetScaleFactors1x2x(), &results);
+      kSmallSize.width(), GetScaleFactors1x2x(), &bitmap_results);
 
   // |page_url1| and |page_url2| should still be mapped to the same icon URLs.
   std::vector<IconMapping> icon_mappings;
   EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingsForPageURL(page_url1,
       &icon_mappings));
   EXPECT_EQ(1u, icon_mappings.size());
   EXPECT_EQ(icon_urla, icon_mappings[0].icon_url);
   EXPECT_EQ(TOUCH_ICON, icon_mappings[0].icon_type);
 
   icon_mappings.clear();
@@ skipping 14 matching lines @@
   EXPECT_EQ(icon_urlc, icon_mappings[1].icon_url);
   EXPECT_EQ(TOUCH_PRECOMPOSED_ICON, icon_mappings[1].icon_type);
 }
 
 // Test the results of GetFaviconsFromDB() when there are no found
 // favicons.
 TEST_F(HistoryBackendTest, GetFaviconsFromDBEmpty) {
   const GURL page_url("http://www.google.com/");
 
   std::vector<FaviconBitmapResult> bitmap_results;
-  IconURLSizesMap icon_url_sizes;
   EXPECT_FALSE(backend_->GetFaviconsFromDB(page_url, FAVICON,
-      kSmallSize.width(), GetScaleFactors1x2x(), &bitmap_results,
-      &icon_url_sizes));
+      kSmallSize.width(), GetScaleFactors1x2x(), &bitmap_results));
   EXPECT_TRUE(bitmap_results.empty());
-  EXPECT_TRUE(icon_url_sizes.empty());
 }
 
 // Test the results of GetFaviconsFromDB() when there are matching favicons
 // but there are no associated favicon bitmaps.
 TEST_F(HistoryBackendTest, GetFaviconsFromDBNoFaviconBitmaps) {
   const GURL page_url("http://www.google.com/");
   const GURL icon_url("http://www.google.com/icon1");
 
-  IconURLSizesMap icon_url_sizes;
-  icon_url_sizes[icon_url] = GetSizesSmallAndLarge();
-
-  // No favicon bitmaps.
-  std::vector<FaviconBitmapData> favicon_bitmap_data;
-
-  backend_->SetFavicons(page_url, FAVICON, favicon_bitmap_data,
-                        icon_url_sizes);
+  FaviconID icon_id = backend_->thumbnail_db_->AddFavicon(icon_url, FAVICON,
+      GetSizesSmallAndLarge());
+  EXPECT_NE(0, icon_id);
+  EXPECT_NE(0, backend_->thumbnail_db_->AddIconMapping(page_url, icon_id));
 
   std::vector<FaviconBitmapResult> bitmap_results_out;
-  IconURLSizesMap icon_url_sizes_out;
-  EXPECT_TRUE(backend_->GetFaviconsFromDB(page_url, FAVICON, kSmallSize.width(),
-      GetScaleFactors1x2x(), &bitmap_results_out, &icon_url_sizes_out));
+  EXPECT_FALSE(backend_->GetFaviconsFromDB(page_url, FAVICON,
+      kSmallSize.width(), GetScaleFactors1x2x(), &bitmap_results_out));
   EXPECT_TRUE(bitmap_results_out.empty());
-  EXPECT_EQ(icon_url_sizes, icon_url_sizes_out);
 }
 
 // Test that GetFaviconsFromDB() returns results for the bitmaps which most
 // closely match the passed in desired size and scale factors.
 TEST_F(HistoryBackendTest, GetFaviconsFromDBSelectClosestMatch) {
   const GURL page_url("http://www.google.com/");
-
   const GURL icon_url("http://www.google.com/icon1");
-  IconURLSizesMap icon_url_sizes;
-  icon_url_sizes[icon_url] = GetSizesTinySmallAndLarge();
 
   std::vector<FaviconBitmapData> favicon_bitmap_data;
   GenerateFaviconBitmapData(icon_url, GetSizesTinySmallAndLarge(),
                             &favicon_bitmap_data);
 
-  backend_->SetFavicons(page_url, FAVICON, favicon_bitmap_data,
-                        icon_url_sizes);
+  backend_->SetFavicons(page_url, FAVICON, favicon_bitmap_data);
 
   std::vector<FaviconBitmapResult> bitmap_results_out;
-  IconURLSizesMap icon_url_sizes_out;
   EXPECT_TRUE(backend_->GetFaviconsFromDB(page_url, FAVICON, kSmallSize.width(),
-      GetScaleFactors1x2x(), &bitmap_results_out, &icon_url_sizes_out));
+      GetScaleFactors1x2x(), &bitmap_results_out));
 
-  // The bitmap data for the 1x and 2x bitmaps should be returned as their sizes
-  // match exactly.
-
+  // The bitmap data for the small and large bitmaps should be returned as their
+  // sizes match exactly.
   EXPECT_EQ(2u, bitmap_results_out.size());
   // No required order for results.
   if (bitmap_results_out[0].pixel_size == kLargeSize) {
     FaviconBitmapResult tmp_result = bitmap_results_out[0];
     bitmap_results_out[0] = bitmap_results_out[1];
     bitmap_results_out[1] = tmp_result;
   }
 
   EXPECT_FALSE(bitmap_results_out[0].expired);
   EXPECT_TRUE(BitmapDataEqual('b', bitmap_results_out[0].bitmap_data));
   EXPECT_EQ(kSmallSize, bitmap_results_out[0].pixel_size);
   EXPECT_EQ(icon_url, bitmap_results_out[0].icon_url);
   EXPECT_EQ(FAVICON, bitmap_results_out[0].icon_type);
 
   EXPECT_FALSE(bitmap_results_out[1].expired);
   EXPECT_TRUE(BitmapDataEqual('c', bitmap_results_out[1].bitmap_data));
   EXPECT_EQ(kLargeSize, bitmap_results_out[1].pixel_size);
   EXPECT_EQ(icon_url, bitmap_results_out[1].icon_url);
   EXPECT_EQ(FAVICON, bitmap_results_out[1].icon_type);
-
-  EXPECT_EQ(icon_url_sizes, icon_url_sizes_out);
 }
 
 // Test that GetFaviconsFromDB() returns results from the icon URL whose
 // bitmaps most closely match the passed in desired size and scale factors.
 TEST_F(HistoryBackendTest, GetFaviconsFromDBSingleIconURL) {
   const GURL page_url("http://www.google.com/");
 
   const GURL icon_url1("http://www.google.com/icon1");
   const GURL icon_url2("http://www.google.com/icon2");
-  IconURLSizesMap icon_url_sizes;
-  icon_url_sizes[icon_url1] = GetSizesSmall();
-  icon_url_sizes[icon_url2] = GetSizesSmallAndLarge();
 
   std::vector<FaviconBitmapData> favicon_bitmap_data;
   GenerateFaviconBitmapData(icon_url1, GetSizesSmall(), icon_url2,
                             GetSizesLarge(), &favicon_bitmap_data);
 
-  backend_->SetFavicons(page_url, FAVICON, favicon_bitmap_data,
-                        icon_url_sizes);
+  backend_->SetFavicons(page_url, FAVICON, favicon_bitmap_data);
 
   std::vector<FaviconBitmapResult> bitmap_results_out;
-  IconURLSizesMap icon_url_sizes_out;
   EXPECT_TRUE(backend_->GetFaviconsFromDB(page_url, FAVICON, kSmallSize.width(),
-      GetScaleFactors1x2x(), &bitmap_results_out, &icon_url_sizes_out));
+      GetScaleFactors1x2x(), &bitmap_results_out));
 
   // The results should have results for the icon URL with the large bitmap as
   // downscaling is preferred to upscaling.
   EXPECT_EQ(1u, bitmap_results_out.size());
   EXPECT_EQ(kLargeSize, bitmap_results_out[0].pixel_size);
   EXPECT_EQ(icon_url2, bitmap_results_out[0].icon_url);
-
-  EXPECT_EQ(icon_url_sizes, icon_url_sizes_out);
 }
 
 // Test the results of GetFaviconsFromDB() when called with different
 // |icon_types|.
 TEST_F(HistoryBackendTest, GetFaviconsFromDBIconType) {
   const GURL page_url("http://www.google.com/");
   const GURL icon_url1("http://www.google.com/icon1.png");
   const GURL icon_url2("http://www.google.com/icon2.png");
 
-  IconURLSizesMap icon_url_sizes;
-  icon_url_sizes[icon_url1] = GetSizesSmall();
-
   std::vector<FaviconBitmapData> favicon_bitmap_data;
   GenerateFaviconBitmapData(icon_url1, GetSizesSmall(),  &favicon_bitmap_data);
-  backend_->SetFavicons(page_url, FAVICON, favicon_bitmap_data,
-                        icon_url_sizes);
+  backend_->SetFavicons(page_url, FAVICON, favicon_bitmap_data);
 
-  IconURLSizesMap touch_icon_url_sizes;
-  touch_icon_url_sizes[icon_url2] = GetSizesSmall();
   GenerateFaviconBitmapData(icon_url2, GetSizesSmall(), &favicon_bitmap_data);
-  backend_->SetFavicons(page_url, TOUCH_ICON, favicon_bitmap_data,
-                        touch_icon_url_sizes);
+  backend_->SetFavicons(page_url, TOUCH_ICON, favicon_bitmap_data);
 
   std::vector<FaviconBitmapResult> bitmap_results_out;
-  IconURLSizesMap icon_url_sizes_out;
   EXPECT_TRUE(backend_->GetFaviconsFromDB(page_url, FAVICON,
-      kSmallSize.width(), GetScaleFactors1x2x(), &bitmap_results_out,
-      &icon_url_sizes_out));
+      kSmallSize.width(), GetScaleFactors1x2x(), &bitmap_results_out));
 
   EXPECT_EQ(1u, bitmap_results_out.size());
   EXPECT_EQ(FAVICON, bitmap_results_out[0].icon_type);
-  EXPECT_EQ(icon_url_sizes, icon_url_sizes_out);
+  EXPECT_EQ(icon_url1, bitmap_results_out[0].icon_url);
 
   bitmap_results_out.clear();
-  icon_url_sizes_out.clear();
   EXPECT_TRUE(backend_->GetFaviconsFromDB(page_url, TOUCH_ICON,
-      kSmallSize.width(), GetScaleFactors1x2x(), &bitmap_results_out,
-      &icon_url_sizes_out));
+      kSmallSize.width(), GetScaleFactors1x2x(), &bitmap_results_out));
 
   EXPECT_EQ(1u, bitmap_results_out.size());
   EXPECT_EQ(TOUCH_ICON, bitmap_results_out[0].icon_type);
-  EXPECT_EQ(touch_icon_url_sizes, icon_url_sizes_out);
+  EXPECT_EQ(icon_url2, bitmap_results_out[0].icon_url);
 }
 
 // Test that GetFaviconsFromDB() correctly sets the expired flag for bitmap
 // reults.
 TEST_F(HistoryBackendTest, GetFaviconsFromDBExpired) {
   const GURL page_url("http://www.google.com/");
   const GURL icon_url("http://www.google.com/icon.png");
 
   std::vector<unsigned char> data;
   data.push_back('a');
   scoped_refptr<base::RefCountedBytes> bitmap_data(
       base::RefCountedBytes::TakeVector(&data));
   base::Time last_updated = base::Time::FromTimeT(0);
   FaviconID icon_id = backend_->thumbnail_db_->AddFavicon(icon_url, FAVICON,
       GetSizesSmallAndLarge(), bitmap_data, last_updated, kSmallSize);
   EXPECT_NE(0, icon_id);
   EXPECT_NE(0, backend_->thumbnail_db_->AddIconMapping(page_url, icon_id));
 
   std::vector<FaviconBitmapResult> bitmap_results_out;
-  IconURLSizesMap icon_url_sizes_out;
   EXPECT_TRUE(backend_->GetFaviconsFromDB(page_url, FAVICON,
-      kSmallSize.width(), GetScaleFactors1x2x(), &bitmap_results_out,
-      &icon_url_sizes_out));
+      kSmallSize.width(), GetScaleFactors1x2x(), &bitmap_results_out));
 
   EXPECT_EQ(1u, bitmap_results_out.size());
   EXPECT_TRUE(bitmap_results_out[0].expired);
 }
 
 // Check that UpdateFaviconMappingsAndFetch() call back to the UI when there is
 // no valid thumbnail database.
 TEST_F(HistoryBackendTest, UpdateFaviconMappingsAndFetchNoDB) {
   // Make the thumbnail database invalid.
   backend_->thumbnail_db_.reset();
 
-  HistoryBackend::FaviconResults results;
-  results.bitmap_results.push_back(FaviconBitmapResult());
-  results.size_map[GURL()] = FaviconSizes();
+  std::vector<FaviconBitmapResult> bitmap_results;
 
   backend_->UpdateFaviconMappingsAndFetch(
       GURL(), std::vector<GURL>(), FAVICON, kSmallSize.width(),
-      GetScaleFactors1x2x(), &results);
+      GetScaleFactors1x2x(), &bitmap_results);
 
-  EXPECT_TRUE(results.bitmap_results.empty());
-  EXPECT_TRUE(results.size_map.empty());
+  EXPECT_TRUE(bitmap_results.empty());
 }
 
 TEST_F(HistoryBackendTest, CloneFaviconIsRestrictedToSameDomain) {
   const GURL url("http://www.google.com/");
   const GURL same_domain_url("http://www.google.com/subdir/index.html");
   const GURL foreign_domain_url("http://www.not-google.com/");
   const GURL icon_url("http://www.google.com/icon.png");
 
   // Add a favicon
-  IconURLSizesMap icon_url_sizes;
-  icon_url_sizes[icon_url] = GetSizesSmall();
-
   std::vector<FaviconBitmapData> favicon_bitmap_data;
   GenerateFaviconBitmapData(icon_url, GetSizesSmall(),  &favicon_bitmap_data);
-  backend_->SetFavicons(url, FAVICON, favicon_bitmap_data, icon_url_sizes);
+  backend_->SetFavicons(url, FAVICON, favicon_bitmap_data);
   EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingsForPageURL(
       url, FAVICON, NULL));
 
   // Validate starting state.
   std::vector<FaviconBitmapResult> bitmap_results_out;
-  IconURLSizesMap icon_url_sizes_out;
   EXPECT_TRUE(backend_->GetFaviconsFromDB(url, FAVICON,
-      kSmallSize.width(), GetScaleFactors1x2x(), &bitmap_results_out,
-      &icon_url_sizes_out));
+      kSmallSize.width(), GetScaleFactors1x2x(), &bitmap_results_out));
   EXPECT_FALSE(backend_->GetFaviconsFromDB(same_domain_url, FAVICON,
-      kSmallSize.width(), GetScaleFactors1x2x(), &bitmap_results_out,
-      &icon_url_sizes_out));
+      kSmallSize.width(), GetScaleFactors1x2x(), &bitmap_results_out));
   EXPECT_FALSE(backend_->GetFaviconsFromDB(foreign_domain_url, FAVICON,
-      kSmallSize.width(), GetScaleFactors1x2x(), &bitmap_results_out,
-      &icon_url_sizes_out));
+      kSmallSize.width(), GetScaleFactors1x2x(), &bitmap_results_out));
 
   // Same-domain cloning should work.
   backend_->CloneFavicons(url, same_domain_url);
   EXPECT_TRUE(backend_->GetFaviconsFromDB(same_domain_url, FAVICON,
-      kSmallSize.width(), GetScaleFactors1x2x(), &bitmap_results_out,
-      &icon_url_sizes_out));
+      kSmallSize.width(), GetScaleFactors1x2x(), &bitmap_results_out));
 
   // Foreign-domain cloning is forbidden.
   backend_->CloneFavicons(url, foreign_domain_url);
   EXPECT_FALSE(backend_->GetFaviconsFromDB(foreign_domain_url, FAVICON,
-      kSmallSize.width(), GetScaleFactors1x2x(), &bitmap_results_out,
-      &icon_url_sizes_out));
+      kSmallSize.width(), GetScaleFactors1x2x(), &bitmap_results_out));
 }
 
 TEST_F(HistoryBackendTest, QueryFilteredURLs) {
   const char* google = "http://www.google.com/";
   const char* yahoo = "http://www.yahoo.com/";
   const char* yahoo_sports = "http://sports.yahoo.com/";
   const char* yahoo_sports_with_article1 =
       "http://sports.yahoo.com/article1.htm";
   const char* yahoo_sports_with_article2 =
       "http://sports.yahoo.com/article2.htm";
@@ skipping 347 matching lines @@
             backend_->GetFirstRecordedTimeForTest());
 
   EXPECT_FALSE(backend_->GetURL(args[0].url, &row));
   EXPECT_TRUE(backend_->GetURL(args[1].url, &row));
   EXPECT_FALSE(backend_->GetURL(args[2].url, &row));
   EXPECT_TRUE(backend_->GetURL(args[3].url, &row));
   EXPECT_FALSE(backend_->GetURL(args[4].url, &row));
 }
 
 }  // namespace history