Adds support for saving favicon size into history database.

chrome/browser/history/thumbnail_database_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 <vector>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
@@ skipping 31 matching lines @@
 const double kBoringness = 0.25;
 const double kWorseBoringness = 0.50;
 const double kBetterBoringness = 0.10;
 const double kTotallyBoring = 1.0;
 
 const int64 kPage1 = 1234;
 
 const gfx::Size kSmallSize = gfx::Size(16, 16);
 const gfx::Size kLargeSize = gfx::Size(32, 32);
 
-const std::string kSizesSmallAndLarge = "16 16 32 32";
-
 }  // namespace
 
 class ThumbnailDatabaseTest : public testing::Test {
  public:
   ThumbnailDatabaseTest() {
   }
   ~ThumbnailDatabaseTest() {
   }
 
  protected:
   virtual void SetUp() {
     // Get a temporary directory for the test DB files.
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
 
     file_name_ = temp_dir_.path().AppendASCII("TestThumbnails.db");
     new_file_name_ = temp_dir_.path().AppendASCII("TestFavicons.db");
     history_db_name_ = temp_dir_.path().AppendASCII("TestHistory.db");
     google_bitmap_.reset(
         gfx::JPEGCodec::Decode(kGoogleThumbnail, sizeof(kGoogleThumbnail)));
   }
 
+  const FaviconSizes& GetSizesSmallAndLarge() {
+    CR_DEFINE_STATIC_LOCAL(FaviconSizes, kSizesSmallAndLarge, ());
+    if (kSizesSmallAndLarge.empty()) {
+      kSizesSmallAndLarge.push_back(kSmallSize);
+      kSizesSmallAndLarge.push_back(kLargeSize);
+    }
+    return kSizesSmallAndLarge;
+  }
+
   scoped_ptr<SkBitmap> google_bitmap_;
 
   ScopedTempDir temp_dir_;
   FilePath file_name_;
   FilePath new_file_name_;
   FilePath history_db_name_;
+  FaviconSizes sizes_small_and_large_;
 };
 
 class IconMappingMigrationTest : public HistoryUnitTestBase {
  public:
   IconMappingMigrationTest() {
   }
   ~IconMappingMigrationTest() {
   }
 
  protected:
@@ skipping 27 matching lines @@
 TEST_F(ThumbnailDatabaseTest, GetFaviconAfterMigrationToTopSites) {
   ThumbnailDatabase db;
   ASSERT_EQ(sql::INIT_OK, db.Init(file_name_, NULL, NULL));
   db.BeginTransaction();
 
   std::vector<unsigned char> data(blob1, blob1 + sizeof(blob1));
   scoped_refptr<base::RefCountedBytes> favicon(new base::RefCountedBytes(data));
 
   GURL url("http://google.com");
   FaviconID icon_id = db.AddFavicon(url, FAVICON);
-  db.SetFaviconSizes(icon_id, kSizesSmallAndLarge);
+  db.SetFaviconSizes(icon_id, GetSizesSmallAndLarge());
   base::Time time = base::Time::Now();
   FaviconBitmapID bitmap1_id = db.AddFaviconBitmap(icon_id, favicon, time,
                                                    kSmallSize);
   FaviconBitmapID bitmap2_id = db.AddFaviconBitmap(icon_id, favicon, time,
                                                    kLargeSize);
   EXPECT_TRUE(db.RenameAndDropThumbnails(file_name_, new_file_name_));
   EXPECT_TRUE(db.IsLatestVersion());
 
   GURL url_out;
   IconType icon_type_out;
-  std::string sizes_out;
+  FaviconSizes sizes_out;
   EXPECT_TRUE(db.GetFaviconHeader(icon_id, &url_out, &icon_type_out,
                                   &sizes_out));
 
   EXPECT_EQ(url, url_out);
   EXPECT_EQ(FAVICON, icon_type_out);
-  EXPECT_STREQ(kSizesSmallAndLarge.c_str(), sizes_out.c_str());
+  EXPECT_EQ(GetSizesSmallAndLarge(), sizes_out);
 
   std::vector<FaviconBitmap> favicon_bitmaps_out;
   EXPECT_TRUE(db.GetFaviconBitmaps(icon_id, &favicon_bitmaps_out));
   EXPECT_EQ(2u, favicon_bitmaps_out.size());
 
   FaviconBitmap favicon_bitmap1 = favicon_bitmaps_out[0];
   FaviconBitmap favicon_bitmap2 = favicon_bitmaps_out[1];
 
-  // Bitmaps do not need to be in particular order.
+  // Favicon bitmaps do not need to be in particular order.
   if (favicon_bitmap1.bitmap_id == bitmap2_id) {
     FaviconBitmap tmp_favicon_bitmap = favicon_bitmap1;
     favicon_bitmap1 = favicon_bitmap2;
     favicon_bitmap2 = tmp_favicon_bitmap;
   }
 
   EXPECT_EQ(bitmap1_id, favicon_bitmap1.bitmap_id);
   EXPECT_EQ(icon_id, favicon_bitmap1.icon_id);
   EXPECT_EQ(time.ToTimeT(), favicon_bitmap1.last_updated.ToTimeT());
   EXPECT_EQ(data.size(), favicon_bitmap1.bitmap_data->size());
@@ skipping 20 matching lines @@
   std::vector<unsigned char> data(blob1, blob1 + sizeof(blob1));
   scoped_refptr<base::RefCountedBytes> favicon(new base::RefCountedBytes(data));
 
   GURL url("http://google.com");
   FaviconID id = db.AddFavicon(url, TOUCH_ICON);
   EXPECT_NE(0, id);
   base::Time time = base::Time::Now();
   db.AddFaviconBitmap(id, favicon, time, gfx::Size());
 
   EXPECT_NE(0, db.AddIconMapping(url, id));
-  std::vector<IconMapping> icon_mapping;
-  EXPECT_TRUE(db.GetIconMappingsForPageURL(url, &icon_mapping));
-  EXPECT_EQ(1u, icon_mapping.size());
-  EXPECT_EQ(url, icon_mapping.front().page_url);
-  EXPECT_EQ(id, icon_mapping.front().icon_id);
+  std::vector<IconMapping> icon_mappings;
+  EXPECT_TRUE(db.GetIconMappingsForPageURL(url, &icon_mappings));
+  EXPECT_EQ(1u, icon_mappings.size());
+  EXPECT_EQ(url, icon_mappings.front().page_url);
+  EXPECT_EQ(id, icon_mappings.front().icon_id);
 }
 
 TEST_F(ThumbnailDatabaseTest, UpdateIconMapping) {
   ThumbnailDatabase db;
   ASSERT_EQ(sql::INIT_OK, db.Init(file_name_, NULL, NULL));
   db.BeginTransaction();
 
   std::vector<unsigned char> data(blob1, blob1 + sizeof(blob1));
   scoped_refptr<base::RefCountedBytes> favicon(new base::RefCountedBytes(data));
 
@@ skipping 37 matching lines @@
 
   FaviconID id2 = db.AddFavicon(url, FAVICON);
   db.AddFaviconBitmap(id2, favicon, time, gfx::Size());
   EXPECT_TRUE(0 < db.AddIconMapping(url, id2));
   ASSERT_NE(id, id2);
 
   std::vector<IconMapping> icon_mapping;
   EXPECT_TRUE(db.GetIconMappingsForPageURL(url, &icon_mapping));
   ASSERT_EQ(2u, icon_mapping.size());
   EXPECT_EQ(icon_mapping.front().icon_type, TOUCH_ICON);
-  EXPECT_TRUE(db.GetIconMappingForPageURL(url, FAVICON, NULL));
+  EXPECT_TRUE(db.GetIconMappingsForPageURL(url, FAVICON, NULL));
 
   db.DeleteIconMappings(url);
 
   EXPECT_FALSE(db.GetIconMappingsForPageURL(url, NULL));
-  EXPECT_FALSE(db.GetIconMappingForPageURL(url, FAVICON, NULL));
+  EXPECT_FALSE(db.GetIconMappingsForPageURL(url, FAVICON, NULL));
 }
 
 TEST_F(ThumbnailDatabaseTest, GetIconMappingsForPageURL) {
   ThumbnailDatabase db;
   ASSERT_EQ(sql::INIT_OK, db.Init(file_name_, NULL, NULL));
   db.BeginTransaction();
 
   std::vector<unsigned char> data(blob1, blob1 + sizeof(blob1));
   scoped_refptr<base::RefCountedBytes> favicon(new base::RefCountedBytes(data));
 
@@ skipping 180 matching lines @@
   db.AddIconMapping(page_url, kept_id);
 
   FaviconID new_favicon_id =
       db.CopyFaviconAndFaviconBitmapsToTemporaryTables(kept_id);
   EXPECT_NE(0, new_favicon_id);
   EXPECT_TRUE(db.AddToTemporaryIconMappingTable(page_url, new_favicon_id));
 
   EXPECT_TRUE(db.CommitTemporaryTables());
 
   // Only copied data should be left.
-  IconMapping icon_mapping;
-  EXPECT_TRUE(db.GetIconMappingForPageURL(page_url, FAVICON, &icon_mapping));
-  EXPECT_EQ(new_favicon_id, icon_mapping.icon_id);
-  EXPECT_EQ(page_url, icon_mapping.page_url);
+  std::vector<IconMapping> icon_mappings;
+  EXPECT_TRUE(db.GetIconMappingsForPageURL(page_url, FAVICON, &icon_mappings));
+  EXPECT_EQ(1u, icon_mappings.size());
+  EXPECT_EQ(new_favicon_id, icon_mappings[0].icon_id);
+  EXPECT_EQ(page_url, icon_mappings[0].page_url);
 
   std::vector<FaviconBitmap> favicon_bitmaps;
-  EXPECT_TRUE(db.GetFaviconBitmaps(icon_mapping.icon_id, &favicon_bitmaps));
+  EXPECT_TRUE(db.GetFaviconBitmaps(icon_mappings[0].icon_id, &favicon_bitmaps));
   EXPECT_EQ(1u, favicon_bitmaps.size());
   EXPECT_EQ(kLargeSize, favicon_bitmaps[0].pixel_size);
 
-  EXPECT_FALSE(db.GetFaviconIDForFaviconURL(unkept_url, false, NULL));
+  EXPECT_FALSE(db.GetFaviconIDForFaviconURL(unkept_url, false));
 }
 
 // Tests that deleting a favicon deletes the favicon row and favicon bitmap
 // rows from the database.
 TEST_F(ThumbnailDatabaseTest, DeleteFavicon) {
   ThumbnailDatabase db;
   ASSERT_EQ(sql::INIT_OK, db.Init(file_name_, NULL, NULL));
   db.BeginTransaction();
 
   std::vector<unsigned char> data1(blob1, blob1 + sizeof(blob1));
@@ skipping 62 matching lines @@
   EXPECT_NE(0, db.AddIconMapping(url, id3));
 
   icon_mapping.clear();
   EXPECT_TRUE(db.GetIconMappingsForPageURL(url, &icon_mapping));
 
   EXPECT_EQ(url, icon_mapping.front().page_url);
   EXPECT_EQ(id3, icon_mapping.front().icon_id);
   EXPECT_EQ(TOUCH_PRECOMPOSED_ICON, icon_mapping.front().icon_type);
 }
 
+// Test result of GetIconMappingsForPageURL when an icon type is passed in.
+TEST_F(ThumbnailDatabaseTest, GetIconMappingsForPageURLWithIconType) {
+  ThumbnailDatabase db;
+  ASSERT_EQ(sql::INIT_OK, db.Init(file_name_, NULL, NULL));
+  db.BeginTransaction();
+
+  GURL url("http://google.com");
+  std::vector<unsigned char> data(blob1, blob1 + sizeof(blob1));
+  scoped_refptr<base::RefCountedBytes> favicon(new base::RefCountedBytes(data));
+  base::Time time = base::Time::Now();
+
+  FaviconID id1 = db.AddFavicon(url, FAVICON, kDefaultFaviconSizes, favicon,
+                                time, gfx::Size());
+  EXPECT_NE(0, db.AddIconMapping(url, id1));
+
+  FaviconID id2 = db.AddFavicon(url, TOUCH_ICON, kDefaultFaviconSizes, favicon,
+                                time, gfx::Size());
+  EXPECT_NE(0, db.AddIconMapping(url, id2));
+
+  std::vector<IconMapping> icon_mappings;
+  EXPECT_TRUE(db.GetIconMappingsForPageURL(url, FAVICON | TOUCH_ICON,
+                                           &icon_mappings));
+  EXPECT_EQ(2u, icon_mappings.size());
+  EXPECT_EQ(id2, icon_mappings[0].icon_id);
+  EXPECT_EQ(id1, icon_mappings[1].icon_id);
+
+  icon_mappings.clear();
+  EXPECT_TRUE(db.GetIconMappingsForPageURL(url, TOUCH_ICON, &icon_mappings));
+  EXPECT_EQ(1u, icon_mappings.size());
+  EXPECT_EQ(id2, icon_mappings[0].icon_id);
+}
+
 TEST_F(ThumbnailDatabaseTest, HasMappingFor) {
   ThumbnailDatabase db;
   ASSERT_EQ(sql::INIT_OK, db.Init(file_name_, NULL, NULL));
   db.BeginTransaction();
 
   std::vector<unsigned char> data(blob1, blob1 + sizeof(blob1));
   scoped_refptr<base::RefCountedBytes> favicon(new base::RefCountedBytes(data));
 
   // Add a favicon which will have icon_mappings
   FaviconID id1 = db.AddFavicon(GURL("http://google.com"), FAVICON);
@@ skipping 22 matching lines @@
   EXPECT_TRUE(db.HasMappingFor(id2));
   EXPECT_FALSE(db.HasMappingFor(id3));
 
   // Remove all mappings
   db.DeleteIconMappings(page_url);
   EXPECT_FALSE(db.HasMappingFor(id1));
   EXPECT_FALSE(db.HasMappingFor(id2));
   EXPECT_FALSE(db.HasMappingFor(id3));
 }
 
-TEST_F(ThumbnailDatabaseTest, CloneIconMapping) {
+TEST_F(ThumbnailDatabaseTest, CloneIconMappings) {
   ThumbnailDatabase db;
   ASSERT_EQ(sql::INIT_OK, db.Init(file_name_, NULL, NULL));
   db.BeginTransaction();
 
   std::vector<unsigned char> data(blob1, blob1 + sizeof(blob1));
   scoped_refptr<base::RefCountedBytes> favicon(new base::RefCountedBytes(data));
 
   // Add a favicon which will have icon_mappings
   FaviconID id1 = db.AddFavicon(GURL("http://google.com"), FAVICON);
   EXPECT_NE(0, id1);
@@ skipping 17 matching lines @@
   EXPECT_TRUE(db.AddIconMapping(page1_url, id2));
 
   GURL page2_url("http://page2.com");
   EXPECT_TRUE(db.AddIconMapping(page2_url, id3));
 
   // Test we do nothing with existing mappings.
   std::vector<IconMapping> icon_mapping;
   EXPECT_TRUE(db.GetIconMappingsForPageURL(page2_url, &icon_mapping));
   ASSERT_EQ(1U, icon_mapping.size());
 
-  EXPECT_TRUE(db.CloneIconMapping(page1_url, page2_url));
+  EXPECT_TRUE(db.CloneIconMappings(page1_url, page2_url));
 
   icon_mapping.clear();
   EXPECT_TRUE(db.GetIconMappingsForPageURL(page2_url, &icon_mapping));
   ASSERT_EQ(1U, icon_mapping.size());
   EXPECT_EQ(page2_url, icon_mapping[0].page_url);
   EXPECT_EQ(id3, icon_mapping[0].icon_id);
 
   // Test we clone if the new page has no mappings.
   GURL page3_url("http://page3.com");
-  EXPECT_TRUE(db.CloneIconMapping(page1_url, page3_url));
+  EXPECT_TRUE(db.CloneIconMappings(page1_url, page3_url));
 
   icon_mapping.clear();
   EXPECT_TRUE(db.GetIconMappingsForPageURL(page3_url, &icon_mapping));
 
   ASSERT_EQ(2U, icon_mapping.size());
   if (icon_mapping[0].icon_id == id2)
     std::swap(icon_mapping[0], icon_mapping[1]);
   EXPECT_EQ(page3_url, icon_mapping[0].page_url);
   EXPECT_EQ(id1, icon_mapping[0].icon_id);
   EXPECT_EQ(page3_url, icon_mapping[1].page_url);
@@ skipping 14 matching lines @@
 
   // Migration should be done.
   // Test one icon_mapping.
   GURL page_url1 = GURL("http://google.com/");
   std::vector<IconMapping> icon_mappings;
   EXPECT_TRUE(db.GetIconMappingsForPageURL(page_url1, &icon_mappings));
   ASSERT_EQ(1u, icon_mappings.size());
   EXPECT_EQ(FAVICON, icon_mappings[0].icon_type);
   EXPECT_EQ(page_url1, icon_mappings[0].page_url);
   EXPECT_EQ(1, icon_mappings[0].icon_id);
-  base::Time time;
-  scoped_refptr<base::RefCountedMemory> out_data;
-  GURL out_icon_url;
-  ASSERT_TRUE(db.GetFavicon(
-      icon_mappings[0].icon_id, &time, &out_data, &out_icon_url, NULL));
-  EXPECT_EQ(icon1, out_icon_url);
+  EXPECT_EQ(icon1, icon_mappings[0].icon_url);
 
   // Test a page which has the same icon.
   GURL page_url3 = GURL("http://www.google.com/");
   icon_mappings.clear();
   EXPECT_TRUE(db.GetIconMappingsForPageURL(page_url3, &icon_mappings));
   ASSERT_EQ(1u, icon_mappings.size());
   EXPECT_EQ(FAVICON, icon_mappings[0].icon_type);
   EXPECT_EQ(page_url3, icon_mappings[0].page_url);
   EXPECT_EQ(1, icon_mappings[0].icon_id);
+  EXPECT_EQ(icon1, icon_mappings[0].icon_url);
 
   // Test a icon_mapping with different IconID.
   GURL page_url2 = GURL("http://yahoo.com/");
   icon_mappings.clear();
   EXPECT_TRUE(db.GetIconMappingsForPageURL(page_url2, &icon_mappings));
   ASSERT_EQ(1u, icon_mappings.size());
   EXPECT_EQ(FAVICON, icon_mappings[0].icon_type);
   EXPECT_EQ(page_url2, icon_mappings[0].page_url);
   EXPECT_EQ(2, icon_mappings[0].icon_id);
-  ASSERT_TRUE(db.GetFavicon(
-      icon_mappings[0].icon_id, &time, &out_data, &out_icon_url, NULL));
-  EXPECT_EQ(icon2, out_icon_url);
+  EXPECT_EQ(icon2, icon_mappings[0].icon_url);
 
   // Test a page without icon
   GURL page_url4 = GURL("http://www.google.com/blank.html");
   EXPECT_FALSE(db.GetIconMappingsForPageURL(page_url4, NULL));
 }
 
 TEST_F(ThumbnailDatabaseTest, IconMappingEnumerator) {
   ThumbnailDatabase db;
   ASSERT_EQ(sql::INIT_OK, db.Init(file_name_, NULL, NULL));
   db.BeginTransaction();
 
   std::vector<unsigned char> data(blob1, blob1 + sizeof(blob1));
   scoped_refptr<base::RefCountedBytes> favicon(new base::RefCountedBytes(data));
 
   GURL url("http://google.com");
-  FaviconID touch_icon_id1 = db.AddFavicon(url, TOUCH_ICON);
+  GURL icon_url1("http://google.com/favicon.ico");
+  FaviconID touch_icon_id1 = db.AddFavicon(icon_url1, TOUCH_ICON,
+      GetSizesSmallAndLarge(), favicon, base::Time::Now(), kSmallSize);
   ASSERT_NE(0, touch_icon_id1);
-  ASSERT_TRUE(db.AddFaviconBitmap(touch_icon_id1, favicon, base::Time::Now(),
-                                  gfx::Size()));
   IconMappingID touch_mapping_id1 = db.AddIconMapping(url, touch_icon_id1);
   ASSERT_NE(0, touch_mapping_id1);
 
-  FaviconID favicon_id1 = db.AddFavicon(url, FAVICON);
+  FaviconID favicon_id1 = db.AddFavicon(icon_url1, FAVICON,
+                                        GetSizesSmallAndLarge(),
+      favicon, base::Time::Now(), kSmallSize);
   ASSERT_NE(0, favicon_id1);
-  ASSERT_TRUE(db.AddFaviconBitmap(favicon_id1, favicon, base::Time::Now(),
-                                  gfx::Size()));
   IconMappingID favicon_mapping_id1 = db.AddIconMapping(url, favicon_id1);
   ASSERT_NE(0, favicon_mapping_id1);
 
   GURL url2("http://chromium.org");
-  FaviconID favicon_id2 = db.AddFavicon(url2, FAVICON);
+  GURL icon_url2("http://chromium.org/favicon.ico");
+  FaviconID favicon_id2 = db.AddFavicon(icon_url2, FAVICON,
+                                        GetSizesSmallAndLarge(),
+      favicon, base::Time::Now(), kSmallSize);
   ASSERT_NE(0, favicon_id2);
-  ASSERT_TRUE(db.AddFaviconBitmap(favicon_id2, favicon, base::Time::Now(),
-                                  gfx::Size()));
   IconMappingID favicon_mapping_id2 = db.AddIconMapping(url2, favicon_id2);
   ASSERT_NE(0, favicon_mapping_id2);
 
   IconMapping icon_mapping;
   ThumbnailDatabase::IconMappingEnumerator enumerator1;
   ASSERT_TRUE(db.InitIconMappingEnumerator(FAVICON, &enumerator1));
   // There are 2 favicon mappings.
   bool has_favicon_mapping1 = false;
   bool has_favicon_mapping2 = false;
   int mapping_count = 0;
   while (enumerator1.GetNextIconMapping(&icon_mapping)) {
     mapping_count++;
     if (favicon_mapping_id1 == icon_mapping.mapping_id) {
       has_favicon_mapping1 = true;
       EXPECT_EQ(url, icon_mapping.page_url);
       EXPECT_EQ(favicon_id1, icon_mapping.icon_id);
+      EXPECT_EQ(icon_url1, icon_mapping.icon_url);
       EXPECT_EQ(FAVICON, icon_mapping.icon_type);
     } else if (favicon_mapping_id2 == icon_mapping.mapping_id) {
       has_favicon_mapping2 = true;
       EXPECT_EQ(url2, icon_mapping.page_url);
       EXPECT_EQ(favicon_id2, icon_mapping.icon_id);
+      EXPECT_EQ(icon_url2, icon_mapping.icon_url);
       EXPECT_EQ(FAVICON, icon_mapping.icon_type);
     }
   }
   EXPECT_EQ(2, mapping_count);
   EXPECT_TRUE(has_favicon_mapping1);
   EXPECT_TRUE(has_favicon_mapping2);
 
   ThumbnailDatabase::IconMappingEnumerator enumerator2;
   ASSERT_TRUE(db.InitIconMappingEnumerator(TOUCH_ICON, &enumerator2));
   ASSERT_TRUE(enumerator2.GetNextIconMapping(&icon_mapping));
   EXPECT_EQ(touch_mapping_id1, icon_mapping.mapping_id);
   EXPECT_EQ(url, icon_mapping.page_url);
   EXPECT_EQ(touch_icon_id1, icon_mapping.icon_id);
+  EXPECT_EQ(icon_url1, icon_mapping.icon_url);
   EXPECT_EQ(TOUCH_ICON, icon_mapping.icon_type);
 
   EXPECT_FALSE(enumerator2.GetNextIconMapping(&icon_mapping));
 }
 
+TEST_F(ThumbnailDatabaseTest, FaviconSizesToAndFromString) {
+  // Invalid input.
+  FaviconSizes sizes_missing_height;
+  EXPECT_FALSE(ThumbnailDatabase::DatabaseStringToFaviconSizes("0 0 10",
+      &sizes_missing_height));
+  EXPECT_EQ(0u, sizes_missing_height.size());
+
+  FaviconSizes sizes_non_int;
+  EXPECT_FALSE(ThumbnailDatabase::DatabaseStringToFaviconSizes("0 0 a 10",
+      &sizes_non_int));
+  EXPECT_EQ(0u, sizes_missing_height.size());
+
+  // Valid input.
+  FaviconSizes sizes_empty;
+  EXPECT_TRUE(ThumbnailDatabase::DatabaseStringToFaviconSizes("",
+      &sizes_empty));
+  EXPECT_EQ(0u, sizes_empty.size());
+
+  FaviconSizes sizes_valid;
+  EXPECT_TRUE(ThumbnailDatabase::DatabaseStringToFaviconSizes("10 15 20 25",
+      &sizes_valid));
+  EXPECT_EQ(2u, sizes_valid.size());
+  if (sizes_valid[0] == gfx::Size(10, 15)) {
+    EXPECT_EQ(sizes_valid[1], gfx::Size(20, 25));
+  } else {
+    EXPECT_EQ(sizes_valid[0], gfx::Size(20, 25));
+    EXPECT_EQ(sizes_valid[1], gfx::Size(10, 15));
+  }
+
+  std::string sizes_as_string;
+  ThumbnailDatabase::FaviconSizesToDatabaseString(sizes_valid,
+                                                  &sizes_as_string);
+  EXPECT_TRUE(sizes_as_string == "10 15 20 25" ||
+              sizes_as_string == "20 25 10 15");
+}
+
 }  // namespace history