Adds support for saving favicon size into history database.

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 <set>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
@@ skipping 27 matching lines @@
 // backend directly. Most of the history backend functions are tested by the
 // history unit test. Because of the elaborate callbacks involved, this is no
 // harder than calling it directly for many things.
 
 namespace {
 
 // data we'll put into the thumbnail database
 static const unsigned char blob1[] =
     "12346102356120394751634516591348710478123649165419234519234512349134";
 
+const gfx::Size kFaviconRegularSize = gfx::Size(16, 16);
+const gfx::Size kFaviconLargeSize = gfx::Size(32, 32);
+
+const gfx::Size kFavicon1xSize = gfx::Size(16, 16);
+const gfx::Size kFavicon2xSize = gfx::Size(32, 32);
+
 }  // namepace
 
 namespace history {
 
 class HistoryBackendTest;
 
 // This must be a separate object since HistoryBackend manages its lifetime.
 // This just forwards the messages we're interested in to the test object.
 class HistoryBackendTestDelegate : public HistoryBackend::Delegate {
  public:
@@ skipping 133 matching lines @@
     URLID id = backend_->db()->GetRowForURL(url, &row);
     VisitVector visits;
     EXPECT_TRUE(backend_->db()->GetVisitsForURL(id, &visits));
     return visits[0].transition;
   }
 
   FilePath getTestDir() {
     return test_dir_;
   }
 
-  FaviconID GetFavicon(const GURL& url, IconType icon_type) {
-    IconMapping icon_mapping;
-    if (backend_->thumbnail_db_->GetIconMappingForPageURL(url, icon_type,
-                                                          &icon_mapping))
-      return icon_mapping.icon_id;
+  FaviconID GetFaviconIDForPageURL(const GURL& page_url, IconType icon_type) {
+    std::vector<IconMapping> icon_mappings;
+    if (backend_->thumbnail_db_->GetIconMappingsForPageURL(page_url, icon_type,
+                                                           &icon_mappings))
+      return icon_mappings[0].icon_id;
     else
       return 0;
   }
 
+  FaviconID GetFaviconIDForIconURL(const GURL& icon_url, IconType icon_type) {
+    std::vector<FaviconIDAndSize> favicon_id_size_listing;
+    backend_->thumbnail_db_->GetFaviconIDsForFaviconURL(
+        icon_url, icon_type, &favicon_id_size_listing);
+    if (favicon_id_size_listing.size() > 0)
+      return favicon_id_size_listing[0].icon_id;
+    else
+      return 0;
+  }
+
+  bool HasFaviconMapping(const GURL& page_url,
+                         const gfx::Size& pixel_size,
+                         int icon_types) {
+    std::vector<IconMapping> icon_mappings;
+    backend_->thumbnail_db_->GetIconMappingsForPageURL(page_url, icon_types,
+                                                       &icon_mappings);
+    for (size_t i = 0; i < icon_mappings.size(); ++i) {
+      if (icon_mappings[i].icon_pixel_size == pixel_size)
+        return true;
+    }
+    return false;
+  }
+
   BookmarkModel bookmark_model_;
 
  protected:
   bool loaded_;
 
  private:
   friend class HistoryBackendTestDelegate;
 
   // testing::Test
   virtual void SetUp() {
@@ skipping 66 matching lines @@
 
 TEST_F(HistoryBackendTest, DeleteAll) {
   ASSERT_TRUE(backend_.get());
 
   // Add two favicons, use the characters '1' and '2' for the image data. Note
   // that we do these in the opposite order. This is so the first one gets ID
   // 2 autoassigned to the database, which will change when the other one is
   // deleted. This way we can test that updating works properly.
   GURL favicon_url1("http://www.google.com/favicon.ico");
   GURL favicon_url2("http://news.google.com/favicon.ico");
-  FaviconID favicon2 = backend_->thumbnail_db_->AddFavicon(favicon_url2,
-                                                           FAVICON);
-  FaviconID favicon1 = backend_->thumbnail_db_->AddFavicon(favicon_url1,
-                                                           FAVICON);
+  FaviconID favicon2 = backend_->thumbnail_db_->AddFavicon(
+      favicon_url2, kFaviconRegularSize, FAVICON);
+  FaviconID favicon1 = backend_->thumbnail_db_->AddFavicon(
+      favicon_url1, kFaviconRegularSize, FAVICON);
 
   std::vector<unsigned char> data;
   data.push_back('1');
   EXPECT_TRUE(backend_->thumbnail_db_->SetFavicon(favicon1,
       new base::RefCountedBytes(data), Time::Now()));
 
   data[0] = '2';
   EXPECT_TRUE(backend_->thumbnail_db_->SetFavicon(
                   favicon2, new base::RefCountedBytes(data), Time::Now()));
 
@@ skipping 86 matching lines @@
   ASSERT_EQ(0U, all_visits.size());
 
   // All thumbnails should be deleted.
   std::vector<unsigned char> out_data;
   EXPECT_FALSE(backend_->thumbnail_db_->GetPageThumbnail(outrow1.id(),
                                                          &out_data));
   EXPECT_FALSE(backend_->thumbnail_db_->GetPageThumbnail(row2_id, &out_data));
 
   // We should have a favicon for the first URL only. We look them up by favicon
   // URL since the IDs may hav changed.
-  FaviconID out_favicon1 = backend_->thumbnail_db_->
-      GetFaviconIDForFaviconURL(favicon_url1, FAVICON, NULL);
+  FaviconID out_favicon1 = GetFaviconIDForIconURL(favicon_url1, FAVICON);
   EXPECT_TRUE(out_favicon1);
-  FaviconID out_favicon2 = backend_->thumbnail_db_->
-      GetFaviconIDForFaviconURL(favicon_url2, FAVICON, NULL);
+  FaviconID out_favicon2 = GetFaviconIDForIconURL(favicon_url2, FAVICON);
   EXPECT_FALSE(out_favicon2) << "Favicon not deleted";
 
   // The remaining URL should still reference the same favicon, even if its
   // ID has changed.
-  EXPECT_EQ(out_favicon1, GetFavicon(outrow1.url(), FAVICON));
+  EXPECT_EQ(out_favicon1, GetFaviconIDForPageURL(outrow1.url(), FAVICON));
 
   // The first URL should still be bookmarked.
   EXPECT_TRUE(bookmark_model_.IsBookmarked(row1.url()));
 
   // The full text database should have no data.
   std::vector<TextDatabase::Match> text_matches;
   Time first_time_searched;
   backend_->text_database_->GetTextMatches(UTF8ToUTF16("Body"),
                                            QueryOptions(),
                                            &text_matches,
@@ skipping 52 matching lines @@
   backend_->text_database_->GetTextMatches(UTF8ToUTF16("Body"),
                                            QueryOptions(),
                                            &text_matches,
                                            &first_time_searched);
   EXPECT_EQ(0U, text_matches.size());
 }
 
 TEST_F(HistoryBackendTest, URLsNoLongerBookmarked) {
   GURL favicon_url1("http://www.google.com/favicon.ico");
   GURL favicon_url2("http://news.google.com/favicon.ico");
-  FaviconID favicon2 = backend_->thumbnail_db_->AddFavicon(favicon_url2,
-                                                           FAVICON);
-  FaviconID favicon1 = backend_->thumbnail_db_->AddFavicon(favicon_url1,
-                                                           FAVICON);
+  FaviconID favicon2 = backend_->thumbnail_db_->AddFavicon(
+      favicon_url2, kFaviconRegularSize, FAVICON);
+  FaviconID favicon1 = backend_->thumbnail_db_->AddFavicon(
+      favicon_url1, kFaviconRegularSize, FAVICON);
 
   std::vector<unsigned char> data;
   data.push_back('1');
   EXPECT_TRUE(backend_->thumbnail_db_->SetFavicon(
                   favicon1, new base::RefCountedBytes(data), Time::Now()));
 
   data[0] = '2';
   EXPECT_TRUE(backend_->thumbnail_db_->SetFavicon(
                   favicon2, new base::RefCountedBytes(data), Time::Now()));
 
@@ skipping 25 matching lines @@
   // the visits.
   backend_->expirer_.DeleteURL(row2.url());
 
   // Make sure url 2 is still valid, but has no visits.
   URLRow tmp_url_row;
   EXPECT_EQ(row2_id, backend_->db_->GetRowForURL(row2.url(), NULL));
   VisitVector visits;
   backend_->db_->GetVisitsForURL(row2_id, &visits);
   EXPECT_EQ(0U, visits.size());
   // The favicon should still be valid.
-  EXPECT_EQ(favicon2,
-      backend_->thumbnail_db_->GetFaviconIDForFaviconURL(favicon_url2,
-                                                         FAVICON,
-                                                         NULL));
+  EXPECT_EQ(favicon2, GetFaviconIDForIconURL(favicon_url2, FAVICON));
 
   // Unstar row2.
   bookmark_utils::RemoveAllBookmarks(&bookmark_model_, row2.url());
 
   // Tell the backend it was unstarred. We have to explicitly do this as
   // BookmarkModel isn't wired up to the backend during testing.
   std::set<GURL> unstarred_urls;
   unstarred_urls.insert(row2.url());
   backend_->URLsNoLongerBookmarked(unstarred_urls);
 
   // The URL should no longer exist.
   EXPECT_FALSE(backend_->db_->GetRowForURL(row2.url(), &tmp_url_row));
   // And the favicon should be deleted.
-  EXPECT_EQ(0,
-      backend_->thumbnail_db_->GetFaviconIDForFaviconURL(favicon_url2,
-                                                         FAVICON,
-                                                         NULL));
+  EXPECT_EQ(0, GetFaviconIDForIconURL(favicon_url2, FAVICON));
 
   // Unstar row 1.
   bookmark_utils::RemoveAllBookmarks(&bookmark_model_, row1.url());
   // Tell the backend it was unstarred. We have to explicitly do this as
   // BookmarkModel isn't wired up to the backend during testing.
   unstarred_urls.clear();
   unstarred_urls.insert(row1.url());
   backend_->URLsNoLongerBookmarked(unstarred_urls);
 
   // The URL should still exist (because there were visits).
   EXPECT_EQ(row1_id, backend_->db_->GetRowForURL(row1.url(), NULL));
 
   // There should still be visits.
   visits.clear();
   backend_->db_->GetVisitsForURL(row1_id, &visits);
   EXPECT_EQ(1U, visits.size());
 
   // The favicon should still be valid.
-  EXPECT_EQ(favicon1,
-      backend_->thumbnail_db_->GetFaviconIDForFaviconURL(favicon_url1,
-                                                         FAVICON,
-                                                         NULL));
+  EXPECT_EQ(favicon1, GetFaviconIDForIconURL(favicon_url1, FAVICON));
 }
 
 // Tests a handful of assertions for a navigation with a type of
 // KEYWORD_GENERATED.
 TEST_F(HistoryBackendTest, KeywordGenerated) {
   ASSERT_TRUE(backend_.get());
 
   GURL url("http://google.com");
 
   Time visit_time = Time::Now() - base::TimeDelta::FromDays(1);
@@ skipping 65 matching lines @@
   AddClientRedirect(url_b, url_c, true, base::Time(),
                     &transition1, &transition2);
   EXPECT_FALSE(transition1 & content::PAGE_TRANSITION_CHAIN_END);
   EXPECT_TRUE(transition2 & content::PAGE_TRANSITION_CHAIN_END);
 }
 
 TEST_F(HistoryBackendTest, ImportedFaviconsTest) {
   // Setup test data - two Urls in the history, one with favicon assigned and
   // one without.
   GURL favicon_url1("http://www.google.com/favicon.ico");
-  FaviconID favicon1 = backend_->thumbnail_db_->AddFavicon(favicon_url1,
-                                                           FAVICON);
+  FaviconID favicon1 = backend_->thumbnail_db_->AddFavicon(
+      favicon_url1, kFaviconRegularSize, FAVICON);
   std::vector<unsigned char> data;
   data.push_back('1');
   EXPECT_TRUE(backend_->thumbnail_db_->SetFavicon(favicon1,
       base::RefCountedBytes::TakeVector(&data), Time::Now()));
   URLRow row1(GURL("http://www.google.com/"));
   row1.set_visit_count(1);
   row1.set_last_visit(Time::Now());
   EXPECT_TRUE(backend_->thumbnail_db_->AddIconMapping(row1.url(), favicon1));
 
   URLRow row2(GURL("http://news.google.com/"));
   row2.set_visit_count(1);
   row2.set_last_visit(Time::Now());
   URLRows rows;
   rows.push_back(row1);
   rows.push_back(row2);
   backend_->AddPagesWithDetails(rows, history::SOURCE_BROWSED);
   URLRow url_row1, url_row2;
   EXPECT_FALSE(backend_->db_->GetRowForURL(row1.url(), &url_row1) == 0);
   EXPECT_FALSE(backend_->db_->GetRowForURL(row2.url(), &url_row2) == 0);
-  EXPECT_FALSE(GetFavicon(row1.url(), FAVICON) == 0);
-  EXPECT_TRUE(GetFavicon(row2.url(), FAVICON) == 0);
+  EXPECT_FALSE(GetFaviconIDForPageURL(row1.url(), FAVICON) == 0);
+  EXPECT_TRUE(GetFaviconIDForPageURL(row2.url(), FAVICON) == 0);
 
   // Now provide one imported favicon for both URLs already in the registry.
   // The new favicon should only be used with the URL that doesn't already have
   // a favicon.
   std::vector<history::ImportedFaviconUsage> favicons;
   history::ImportedFaviconUsage favicon;
   favicon.favicon_url = GURL("http://news.google.com/favicon.ico");
   favicon.png_data.push_back('2');
   favicon.urls.insert(row1.url());
   favicon.urls.insert(row2.url());
   favicons.push_back(favicon);
   backend_->SetImportedFavicons(favicons);
   EXPECT_FALSE(backend_->db_->GetRowForURL(row1.url(), &url_row1) == 0);
   EXPECT_FALSE(backend_->db_->GetRowForURL(row2.url(), &url_row2) == 0);
-  EXPECT_FALSE(GetFavicon(row1.url(), FAVICON) == 0);
-  EXPECT_FALSE(GetFavicon(row2.url(), FAVICON) == 0);
-  EXPECT_FALSE(GetFavicon(row1.url(), FAVICON) ==
-      GetFavicon(row2.url(), FAVICON));
+  EXPECT_FALSE(GetFaviconIDForPageURL(row1.url(), FAVICON) == 0);
+  EXPECT_FALSE(GetFaviconIDForPageURL(row2.url(), FAVICON) == 0);
+  EXPECT_FALSE(GetFaviconIDForPageURL(row1.url(), FAVICON) ==
+      GetFaviconIDForPageURL(row2.url(), FAVICON));
 
   // A URL should not be added to history (to store favicon), if
   // the URL is not bookmarked.
   GURL url3("http://mail.google.com");
   favicons.clear();
   favicon.favicon_url = GURL("http://mail.google.com/favicon.ico");
   favicon.png_data.push_back('3');
   favicon.urls.insert(url3);
   favicons.push_back(favicon);
   backend_->SetImportedFavicons(favicons);
@@ skipping 362 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_url("http://www.google.com/icon");
   std::vector<unsigned char> data(blob1, blob1 + sizeof(blob1));
   // Add a favicon
-  backend_->SetFavicon(
-      url1, icon_url, base::RefCountedBytes::TakeVector(&data), FAVICON);
-  EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingForPageURL(
-      url1, FAVICON, NULL));
-  EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingForPageURL(
-      url2, FAVICON, NULL));
+  backend_->SetFavicon(url1,
+                       icon_url,
+                       base::RefCountedBytes::TakeVector(&data),
+                       kFaviconRegularSize,
+                       FAVICON);
+  EXPECT_TRUE(HasFaviconMapping(url1, kFaviconRegularSize, FAVICON));
+  EXPECT_TRUE(HasFaviconMapping(url2, kFaviconRegularSize, FAVICON));
 
   // Add a touch_icon
-  backend_->SetFavicon(
-      url1, icon_url, base::RefCountedBytes::TakeVector(&data), TOUCH_ICON);
-  EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingForPageURL(
-      url1, TOUCH_ICON, NULL));
-  EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingForPageURL(
-      url2, TOUCH_ICON, NULL));
-  EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingForPageURL(
-      url1, FAVICON, NULL));
+  backend_->SetFavicon(url1,
+                       icon_url,
+                       base::RefCountedBytes::TakeVector(&data),
+                       kFaviconRegularSize,
+                       TOUCH_ICON);
+  EXPECT_TRUE(HasFaviconMapping(url1, kFaviconRegularSize, TOUCH_ICON));
+  EXPECT_TRUE(HasFaviconMapping(url2, kFaviconRegularSize, TOUCH_ICON));
+  EXPECT_TRUE(HasFaviconMapping(url1, kFaviconRegularSize, FAVICON));
+
+  // Add a large touch icon
+  backend_->SetFavicon(url1,
+                       icon_url,
+                       base::RefCountedBytes::TakeVector(&data),
+                       kFaviconLargeSize,
+                       TOUCH_ICON);
+  EXPECT_TRUE(HasFaviconMapping(url1, kFaviconLargeSize, TOUCH_ICON));
+  EXPECT_TRUE(HasFaviconMapping(url2, kFaviconLargeSize, TOUCH_ICON));
+  EXPECT_TRUE(HasFaviconMapping(url1, kFaviconRegularSize, TOUCH_ICON));
+  EXPECT_TRUE(HasFaviconMapping(url1, kFaviconRegularSize, FAVICON));
 
   // Add a TOUCH_PRECOMPOSED_ICON
   backend_->SetFavicon(url1,
                        icon_url,
                        base::RefCountedBytes::TakeVector(&data),
+                       kFaviconRegularSize,
                        TOUCH_PRECOMPOSED_ICON);
-  // The touch_icon was replaced.
-  EXPECT_FALSE(backend_->thumbnail_db_->GetIconMappingForPageURL(
-      url1, TOUCH_ICON, NULL));
-  EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingForPageURL(
-      url1, FAVICON, NULL));
-  EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingForPageURL(
-      url1, TOUCH_PRECOMPOSED_ICON, NULL));
-  EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingForPageURL(
-      url2, TOUCH_PRECOMPOSED_ICON, NULL));
+  // The small touch_icon was replaced.
+  EXPECT_FALSE(HasFaviconMapping(url1, kFaviconRegularSize, TOUCH_ICON));
+  EXPECT_TRUE(HasFaviconMapping(url1, kFaviconLargeSize, TOUCH_ICON));
+  EXPECT_TRUE(HasFaviconMapping(url1, kFaviconRegularSize, FAVICON));
+  EXPECT_TRUE(HasFaviconMapping(url1, kFaviconRegularSize,
+                                TOUCH_PRECOMPOSED_ICON));
+  EXPECT_TRUE(HasFaviconMapping(url2, kFaviconRegularSize,
+                                TOUCH_PRECOMPOSED_ICON));
 
   // Add a touch_icon
-  backend_->SetFavicon(
-      url1, icon_url, base::RefCountedBytes::TakeVector(&data), TOUCH_ICON);
-  EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingForPageURL(
-      url1, TOUCH_ICON, NULL));
-  EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingForPageURL(
-      url1, FAVICON, NULL));
+  backend_->SetFavicon(url1,
+                       icon_url,
+                       base::RefCountedBytes::TakeVector(&data),
+                       kFaviconRegularSize,
+                       TOUCH_ICON);
+  EXPECT_TRUE(HasFaviconMapping(url1, kFaviconRegularSize, TOUCH_ICON));
+  EXPECT_TRUE(HasFaviconMapping(url1, kFaviconLargeSize, TOUCH_ICON));
+  EXPECT_TRUE(HasFaviconMapping(url1, kFaviconRegularSize, FAVICON));
   // The TOUCH_PRECOMPOSED_ICON was replaced.
-  EXPECT_FALSE(backend_->thumbnail_db_->GetIconMappingForPageURL(
-      url1, TOUCH_PRECOMPOSED_ICON, NULL));
+  EXPECT_FALSE(HasFaviconMapping(url1, kFaviconRegularSize,
+                                 TOUCH_PRECOMPOSED_ICON));
 
   // Add a favicon
   const GURL icon_url2("http://www.google.com/icon2");
-  backend_->SetFavicon(
-      url1, icon_url2, base::RefCountedBytes::TakeVector(&data), FAVICON);
-  FaviconID icon_id = backend_->thumbnail_db_->GetFaviconIDForFaviconURL(
-      icon_url2, FAVICON, NULL);
-  EXPECT_NE(0, icon_id);
-  std::vector<IconMapping> icon_mapping;
+  backend_->SetFavicon(url1,
+                       icon_url2,
+                       base::RefCountedBytes::TakeVector(&data),
+                       kFaviconRegularSize,
+                       FAVICON);
+  FaviconID icon_id2 = GetFaviconIDForIconURL(icon_url2, FAVICON);
+  EXPECT_NE(icon_id2, 0);
+  std::vector<IconMapping> icon_mappings;
   EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingsForPageURL(
-      url1, &icon_mapping));
-  // The old icon was replaced.
-  EXPECT_TRUE(icon_mapping.size() > 1);
-  EXPECT_EQ(icon_id, icon_mapping[1].icon_id);
+      url1, FAVICON, &icon_mappings));
+  EXPECT_EQ(1u, icon_mappings.size());
+  EXPECT_EQ(icon_id2, icon_mappings[0].icon_id);
+}
+
+TEST_F(HistoryBackendTest, ExceedPageFaviconLimit) {
+  const GURL page_url("http://www.google.com");
+  const GURL icon_url("http://www.google.com/icon");
+  std::vector<unsigned char> data(blob1, blob1 + sizeof(blob1));
+
+  int size = 10;
+  size_t num_to_insert = kMaxFaviconsPerPage + 1;
+  for (size_t i = 0; i < num_to_insert; ++i) {
+    backend_->SetFavicon(page_url,
+                         icon_url,
+                         base::RefCountedBytes::TakeVector(&data),
+                         gfx::Size(size, size),
+                         FAVICON);
+    size++;
+  }
+
+  std::vector<IconMapping> icon_mappings;
+  EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingsForPageURL(
+      page_url, &icon_mappings));
+  EXPECT_EQ(kMaxFaviconsPerPage, icon_mappings.size());
 }
 
 TEST_F(HistoryBackendTest, AddOrUpdateIconMapping) {
   // Test the same icon and page mapping will not be added twice. other case
   // should be covered in TEST_F(HistoryBackendTest, SetFaviconMapping)
   const GURL url("http://www.google.com/");
   const GURL icon_url("http://www.google.com/icon");
   std::vector<unsigned char> data(blob1, blob1 + sizeof(blob1));
 
-  backend_->SetFavicon(
-      url, icon_url, base::RefCountedBytes::TakeVector(&data), FAVICON);
-  FaviconID icon_id = backend_->thumbnail_db_->GetFaviconIDForFaviconURL(
-      icon_url, FAVICON, NULL);
+  backend_->SetFavicon(url, icon_url,
+      base::RefCountedBytes::TakeVector(&data), kFaviconRegularSize, FAVICON);
+  FaviconID icon_id = GetFaviconIDForIconURL(icon_url, FAVICON);
 
   // Add the same mapping
   FaviconID replaced;
   EXPECT_FALSE(backend_->AddOrUpdateIconMapping(
-      url, icon_id, FAVICON, &replaced));
+      url, icon_id, kFaviconRegularSize, FAVICON, &replaced));
   EXPECT_EQ(0, replaced);
 
   std::vector<IconMapping> icon_mapping;
   EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingsForPageURL(
       url, &icon_mapping));
   EXPECT_EQ(1u, icon_mapping.size());
 }
 
 TEST_F(HistoryBackendTest, GetFaviconForURL) {
   // This test will add a fav icon and touch icon for the same URL
   // and check the behaviour of backend's GetFaviconForURL implementation.
   const GURL url("http://www.google.com/");
   const GURL icon_url("http://www.google.com/icon");
+
   std::vector<unsigned char> data(blob1, blob1 + sizeof(blob1));
-  scoped_refptr<base::RefCountedBytes> bytes(new base::RefCountedBytes(data));
+  scoped_refptr<base::RefCountedBytes> bytes(
+      new base::RefCountedBytes(data));
   // Used for testing the icon data after getting from DB
   std::string blob_data(bytes->front(),
                         bytes->front() + bytes->size());
 
   // Add a favicon
   backend_->SetFavicon(
-      url, icon_url, bytes.get(), FAVICON);
-  EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingForPageURL(
-      url, FAVICON, NULL));
+      url, icon_url, bytes.get(), kFavicon1xSize, FAVICON);
+  EXPECT_TRUE(HasFaviconMapping(url, kFavicon1xSize, FAVICON));
 
-  // Add a touch_icon
+  // Add a small touch_icon
   backend_->SetFavicon(
-      url, icon_url, bytes.get(), TOUCH_ICON);
-  EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingForPageURL(
-      url, TOUCH_ICON, NULL));
+      url, icon_url, bytes.get(), kFavicon1xSize, TOUCH_ICON);
+  EXPECT_TRUE(HasFaviconMapping(url, kFavicon1xSize, TOUCH_ICON));
 
-  // Test the Fav icon for this URL.
+  // Add a large touch icon
+  backend_->SetFavicon(
+      url, icon_url, bytes.get(), kFavicon2xSize, TOUCH_ICON);
+  EXPECT_TRUE(HasFaviconMapping(url, kFavicon2xSize, TOUCH_ICON));
+
+  // Test the Fav small icon for this URL.
   FaviconData favicon;
-  ASSERT_TRUE(backend_->GetFaviconFromDB(url, FAVICON, &favicon));
-  std::string favicon_data(
-      favicon.image_data->front(),
-      favicon.image_data->front() + favicon.image_data->size());
+  ASSERT_TRUE(backend_->GetFaviconFromDB(url, kFavicon1xSize, FAVICON,
+      &favicon));
+  std::string favicon_data_1x(
+      favicon.bitmap_data->front(),
+      favicon.bitmap_data->front() + favicon.bitmap_data->size());
 
   EXPECT_EQ(FAVICON, favicon.icon_type);
   EXPECT_EQ(icon_url, favicon.icon_url);
-  EXPECT_EQ(blob_data, favicon_data);
+  EXPECT_EQ(blob_data, favicon_data_1x);
+  EXPECT_EQ(kFavicon1xSize, favicon.requested_size);
 
-  // Test the touch icon for this URL.
-  ASSERT_TRUE(backend_->GetFaviconFromDB(url, TOUCH_ICON, &favicon));
-  std::string touchicon_data(
-      favicon.image_data->front(),
-      favicon.image_data->front() + favicon.image_data->size());
+  // Test falling back to small icon if the large one is not present.
+  ASSERT_TRUE(backend_->GetFaviconFromDB(url, kFavicon2xSize, FAVICON,
+      &favicon));
+  std::string favicon_data_2x(
+      favicon.bitmap_data->front(),
+      favicon.bitmap_data->front() + favicon.bitmap_data->size());
+
+  EXPECT_EQ(FAVICON, favicon.icon_type);
+  EXPECT_EQ(icon_url, favicon.icon_url);
+  EXPECT_EQ(blob_data, favicon_data_2x);
+  EXPECT_EQ(kFavicon1xSize, favicon.requested_size);
+
+  // Test the small touch icon for this URL.
+  ASSERT_TRUE(backend_->GetFaviconFromDB(url, kFavicon1xSize, TOUCH_ICON,
+      &favicon));
+  std::string touchicon_1x_data(
+      favicon.bitmap_data->front(),
+      favicon.bitmap_data->front() + favicon.bitmap_data->size());
 
   EXPECT_EQ(TOUCH_ICON, favicon.icon_type);
   EXPECT_EQ(icon_url, favicon.icon_url);
-  EXPECT_EQ(blob_data, touchicon_data);
+  EXPECT_EQ(blob_data, touchicon_1x_data);
+  EXPECT_EQ(kFavicon1xSize, favicon.requested_size);
+
+  // Test the large touch icon for this URL.
+  ASSERT_TRUE(backend_->GetFaviconFromDB(url, kFavicon2xSize, TOUCH_ICON,
+      &favicon));
+  std::string touchicon_2x_data(
+      favicon.bitmap_data->front(),
+      favicon.bitmap_data->front() + favicon.bitmap_data->size());
+
+  EXPECT_EQ(TOUCH_ICON, favicon.icon_type);
+  EXPECT_EQ(icon_url, favicon.icon_url);
+  EXPECT_EQ(blob_data, touchicon_2x_data);
+  EXPECT_EQ(kFavicon2xSize, favicon.requested_size);
 }
 
 TEST_F(HistoryBackendTest, CloneFaviconIsRestrictedToSameDomain) {
   const GURL url("http://www.google.com/");
   const GURL icon_url("http://www.google.com/icon");
   const GURL same_domain_url("http://www.google.com/subdir/index.html");
   const GURL foreign_domain_url("http://www.not-google.com/");
 
   // Add a favicon
   std::vector<unsigned char> data(blob1, blob1 + sizeof(blob1));
   scoped_refptr<base::RefCountedBytes> bytes(new base::RefCountedBytes(data));
   backend_->SetFavicon(
-      url, icon_url, bytes.get(), FAVICON);
-  EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingForPageURL(
+      url, icon_url, bytes.get(), kFaviconRegularSize, FAVICON);
+  EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingsForPageURL(
       url, FAVICON, NULL));
 
   // Validate starting state.
   FaviconData favicon;
-  EXPECT_TRUE(backend_->GetFaviconFromDB(url, FAVICON, &favicon));
-  EXPECT_FALSE(backend_->GetFaviconFromDB(same_domain_url, FAVICON, &favicon));
+  EXPECT_TRUE(backend_->GetFaviconFromDB(url, kFaviconRegularSize, FAVICON,
+      &favicon));
+  EXPECT_FALSE(backend_->GetFaviconFromDB(same_domain_url,
+      kFaviconRegularSize, FAVICON, &favicon));
   EXPECT_FALSE(backend_->GetFaviconFromDB(foreign_domain_url,
-                                          FAVICON, &favicon));
+      kFaviconRegularSize, FAVICON, &favicon));
 
   // Same-domain cloning should work.
   backend_->CloneFavicon(url, same_domain_url);
-  EXPECT_TRUE(backend_->GetFaviconFromDB(same_domain_url, FAVICON, &favicon));
+  EXPECT_TRUE(backend_->GetFaviconFromDB(same_domain_url, kFaviconRegularSize,
+      FAVICON, &favicon));
 
   // Foreign-domain cloning is forbidden.
   backend_->CloneFavicon(url, foreign_domain_url);
   EXPECT_FALSE(backend_->GetFaviconFromDB(foreign_domain_url,
-                                          FAVICON, &favicon));
+      kFaviconRegularSize, FAVICON, &favicon));
 }
 
 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 313 matching lines @@
 
     backend_->DeleteURL(url);
     backend_->AddPageNoVisitForBookmark(url, string16());
     backend_->GetURL(url, &row);
     EXPECT_EQ(url, row.url());
     EXPECT_EQ(UTF8ToUTF16(url.spec()), row.title());
     EXPECT_EQ(0, row.visit_count());
 }
 
 }  // namespace history