Add last_requested field to the favicon_bitmaps table of the favicons 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/files/file_enumerator.h"
 #include "base/files/file_path.h"
@@ skipping 48 matching lines @@
   return sql::test::CreateDatabaseFromSQL(db_path, sql_path);
 }
 
 // Verify that the up-to-date database has the expected tables and
 // columns.  Functional tests only check whether the things which
 // should be there are, but do not check if extraneous items are
 // present.  Any extraneous items have the potential to interact
 // negatively with future schema changes.
 void VerifyTablesAndColumns(sql::Connection* db) {
   // [meta], [favicons], [favicon_bitmaps], and [icon_mapping].
-  EXPECT_EQ(4u, sql::test::CountSQLTables(db));
+  EXPECT_EQ(5u, sql::test::CountSQLTables(db));
 
   // Implicit index on [meta], index on [favicons], index on
   // [favicon_bitmaps], two indices on [icon_mapping].
   EXPECT_EQ(5u, sql::test::CountSQLIndices(db));
 
   // [key] and [value].
   EXPECT_EQ(2u, sql::test::CountTableColumns(db, "meta"));
 
   // [id], [url], and [icon_type].
   EXPECT_EQ(3u, sql::test::CountTableColumns(db, "favicons"));
 
   // [id], [icon_id], [last_updated], [image_data], [width], and [height].
   EXPECT_EQ(6u, sql::test::CountTableColumns(db, "favicon_bitmaps"));
 
   // [id], [page_url], and [icon_id].
   EXPECT_EQ(3u, sql::test::CountTableColumns(db, "icon_mapping"));
+
+  // [bitmap_id], [last_requested].
+  EXPECT_EQ(2u, sql::test::CountTableColumns(db, "favicon_bitmap_usage"));
 }
 
 void VerifyDatabaseEmpty(sql::Connection* db) {
   size_t rows = 0;
   EXPECT_TRUE(sql::test::CountTableRows(db, "favicons", &rows));
   EXPECT_EQ(0u, rows);
   EXPECT_TRUE(sql::test::CountTableRows(db, "favicon_bitmaps", &rows));
   EXPECT_EQ(0u, rows);
   EXPECT_TRUE(sql::test::CountTableRows(db, "icon_mapping", &rows));
   EXPECT_EQ(0u, rows);
+  EXPECT_TRUE(sql::test::CountTableRows(db, "favicon_bitmap_usage", &rows));
+  EXPECT_EQ(0u, rows);
 }
 
 // Helper to check that an expected mapping exists.
 WARN_UNUSED_RESULT bool CheckPageHasIcon(
     ThumbnailDatabase* db,
     const GURL& page_url,
     favicon_base::IconType expected_icon_type,
     const GURL& expected_icon_url,
     const gfx::Size& expected_icon_size,
     size_t expected_icon_contents_size,
@@ skipping 43 matching lines @@
   }
 
   if (memcmp(favicon_bitmaps[0].bitmap_data->front(),
              expected_icon_contents, expected_icon_contents_size)) {
     ADD_FAILURE() << "failed to match |expected_icon_contents|";
     return false;
   }
   return true;
 }
 
+WARN_UNUSED_RESULT bool CheckBitmapLastRequestTime(
+    ThumbnailDatabase* db,
+    const GURL& page_url,
+    favicon_base::IconType icon_type,
+    const gfx::Size& icon_size,
+    base::Time* request_timestamp) {
+  std::vector<IconMapping> icon_mappings;
+  if (!db->GetIconMappingsForPageURL(page_url, &icon_mappings)) {
+    ADD_FAILURE() << "failed GetIconMappingsForPageURL()";
+    return false;
+  }
+
+  // Scan for the expected type.
+  std::vector<IconMapping>::const_iterator icon_iter = icon_mappings.begin();
+  for (; icon_iter != icon_mappings.end(); ++icon_iter) {
+    if (icon_iter->icon_type == icon_type)
+      break;
+  }
+  if (icon_iter == icon_mappings.end()) {
+    ADD_FAILURE() << "failed to find |icon_type|";
+    return false;
+  }
+
+  std::vector<FaviconBitmap> favicon_bitmaps;
+  if (!db->GetFaviconBitmaps(icon_iter->icon_id, &favicon_bitmaps)) {
+    ADD_FAILURE() << "failed GetFaviconBitmaps()";
+    return false;
+  }
+
+  std::vector<FaviconBitmap>::const_iterator bitmap_iter =
+      favicon_bitmaps.begin();
+  for (; bitmap_iter != favicon_bitmaps.end(); ++bitmap_iter) {
+    if (bitmap_iter->pixel_size == icon_size)
+      break;
+  }
+
+  if (bitmap_iter == favicon_bitmaps.end()) {
+    ADD_FAILURE() << "failed to find |icon_size|";
+    return false;
+  }
+
+  return db->GetFaviconBitmapLastRequestedTime(bitmap_iter->bitmap_id,
+                                               request_timestamp);
+}
+
 }  // namespace
 
 class ThumbnailDatabaseTest : public testing::Test {
  public:
   ThumbnailDatabaseTest() {
   }
   ~ThumbnailDatabaseTest() override {}
 
   // Initialize a thumbnail database instance from the SQL file at
   // |golden_path| in the "History/" subdirectory of test data.
@@ skipping 590 matching lines @@
                                kBlob1));
   EXPECT_TRUE(CheckPageHasIcon(db.get(),
                                kPageUrl3,
                                favicon_base::TOUCH_ICON,
                                kIconUrl3,
                                kLargeSize,
                                sizeof(kBlob2),
                                kBlob2));
 }
 
+// Test loading version 8 database.
+TEST_F(ThumbnailDatabaseTest, Version8) {
+  scoped_ptr<ThumbnailDatabase> db = LoadFromGolden("Favicons.v8.sql");
+  ASSERT_TRUE(db.get() != NULL);
+  VerifyTablesAndColumns(&db->db_);
+
+  EXPECT_TRUE(CheckPageHasIcon(db.get(),
+                               kPageUrl1,
+                               favicon_base::FAVICON,
+                               kIconUrl1,
+                               kLargeSize,
+                               sizeof(kBlob1),
+                               kBlob1));
+  EXPECT_TRUE(CheckPageHasIcon(db.get(),
+                               kPageUrl2,
+                               favicon_base::FAVICON,
+                               kIconUrl2,
+                               kLargeSize,
+                               sizeof(kBlob2),
+                               kBlob2));
+  EXPECT_TRUE(CheckPageHasIcon(db.get(),
+                               kPageUrl3,
+                               favicon_base::FAVICON,
+                               kIconUrl1,
+                               kLargeSize,
+                               sizeof(kBlob1),
+                               kBlob1));
+  EXPECT_TRUE(CheckPageHasIcon(db.get(),
+                               kPageUrl3,
+                               favicon_base::TOUCH_ICON,
+                               kIconUrl3,
+                               kLargeSize,
+                               sizeof(kBlob2),
+                               kBlob2));
+}
+
 TEST_F(ThumbnailDatabaseTest, Recovery) {
   // This code tests the recovery module in concert with Chromium's
   // custom recover virtual table.  Under USE_SYSTEM_SQLITE, this is
   // not available.  This is detected dynamically because corrupt
   // databases still need to be handled, perhaps by Raze(), and the
   // recovery module is an obvious layer to abstract that to.
   // TODO(shess): Handle that case for real!
   if (!sql::Recovery::FullRecoverySupported())
     return;
 
   // Create an example database.
   {
-    EXPECT_TRUE(CreateDatabaseFromSQL(file_name_, "Favicons.v7.sql"));
+    EXPECT_TRUE(CreateDatabaseFromSQL(file_name_, "Favicons.v8.sql"));
 
     sql::Connection raw_db;
     EXPECT_TRUE(raw_db.Open(file_name_));
     VerifyTablesAndColumns(&raw_db);
   }
 
   // Test that the contents make sense after clean open.
   {
     ThumbnailDatabase db(NULL);
     ASSERT_EQ(sql::INIT_OK, db.Init(file_name_));
@@ skipping 230 matching lines @@
     ThumbnailDatabase db(NULL);
     ASSERT_EQ(sql::INIT_OK, db.Init(db_path));
 
     // Verify that the resulting schema is correct, whether it
     // involved razing the file or fixing things in place.
     VerifyTablesAndColumns(&db.db_);
   }
 }
 
 }  // namespace history