Rename FaviconBitmapXxx to FaviconRawBitmapXxx

chrome/browser/history/thumbnail_database.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 "chrome/browser/history/thumbnail_database.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 282 matching lines @@
       "CREATE TABLE IF NOT EXISTS favicons"
       "("
       "id INTEGER PRIMARY KEY,"
       "url LONGVARCHAR NOT NULL,"
       // default icon_type FAVICON to be consistent with past migration.
       "icon_type INTEGER DEFAULT 1"
       ")";
   if (!db->Execute(kFaviconsSql))
     return false;
 
-  const char kFaviconBitmapsSql[] =
+  const char kFaviconRawBitmapsSql[] =
       "CREATE TABLE IF NOT EXISTS favicon_bitmaps"
       "("
       "id INTEGER PRIMARY KEY,"
       "icon_id INTEGER NOT NULL,"
       "last_updated INTEGER DEFAULT 0,"
       "image_data BLOB,"
       "width INTEGER DEFAULT 0,"
       "height INTEGER DEFAULT 0"
       ")";
-  if (!db->Execute(kFaviconBitmapsSql))
+  if (!db->Execute(kFaviconRawBitmapsSql))
     return false;
 
   return true;
 }
 
 // NOTE(shess): Schema modifications must consider initial creation in
 // |InitImpl()|, recovery in |RecoverDatabaseOrRaze()|, and history pruning in
 // |RetainDataForPageUrls()|.
 bool InitIndices(sql::Connection* db) {
   const char kIconMappingUrlIndexSql[] =
       "CREATE INDEX IF NOT EXISTS icon_mapping_page_url_idx"
       " ON icon_mapping(page_url)";
   const char kIconMappingIdIndexSql[] =
       "CREATE INDEX IF NOT EXISTS icon_mapping_icon_id_idx"
       " ON icon_mapping(icon_id)";
   if (!db->Execute(kIconMappingUrlIndexSql) ||
       !db->Execute(kIconMappingIdIndexSql)) {
     return false;
   }
 
   const char kFaviconsIndexSql[] =
       "CREATE INDEX IF NOT EXISTS favicons_url ON favicons(url)";
   if (!db->Execute(kFaviconsIndexSql))
     return false;
 
-  const char kFaviconBitmapsIndexSql[] =
+  const char kFaviconRawBitmapsIndexSql[] =
       "CREATE INDEX IF NOT EXISTS favicon_bitmaps_icon_id ON "
       "favicon_bitmaps(icon_id)";
-  if (!db->Execute(kFaviconBitmapsIndexSql))
+  if (!db->Execute(kFaviconRawBitmapsIndexSql))
     return false;
 
   return true;
 }
 
 enum RecoveryEventType {
   RECOVERY_EVENT_RECOVERED = 0,
   RECOVERY_EVENT_FAILED_SCOPER,
   RECOVERY_EVENT_FAILED_META_VERSION_ERROR,  // obsolete
   RECOVERY_EVENT_FAILED_META_VERSION_NONE,  // obsolete
@@ skipping 171 matching lines @@
     int percentage = static_cast<int>(original_size * 100 / final_size);
     UMA_HISTOGRAM_PERCENTAGE("History.FaviconsRecoveredPercentage",
                              std::max(100, percentage));
   }
 
   // Using 10,000 because these cases mostly care about "none
   // recovered" and "lots recovered".  More than 10,000 rows recovered
   // probably means there's something wrong with the profile.
   UMA_HISTOGRAM_COUNTS_10000("History.FaviconsRecoveredRowsFavicons",
                              favicons_rows_recovered);
-  UMA_HISTOGRAM_COUNTS_10000("History.FaviconsRecoveredRowsFaviconBitmaps",
+  UMA_HISTOGRAM_COUNTS_10000("History.FaviconsRecoveredRowsFaviconRawBitmaps",
                              favicon_bitmaps_rows_recovered);
   UMA_HISTOGRAM_COUNTS_10000("History.FaviconsRecoveredRowsIconMapping",
                              icon_mapping_rows_recovered);
 
   RecordRecoveryEvent(RECOVERY_EVENT_RECOVERED);
 }
 
 void DatabaseErrorCallback(sql::Connection* db,
                            const base::FilePath& db_path,
                            size_t startup_kb,
@@ skipping 93 matching lines @@
 void ThumbnailDatabase::Vacuum() {
   DCHECK(db_.transaction_nesting() == 0) <<
       "Can not have a transaction when vacuuming.";
   ignore_result(db_.Execute("VACUUM"));
 }
 
 void ThumbnailDatabase::TrimMemory(bool aggressively) {
   db_.TrimMemory(aggressively);
 }
 
-bool ThumbnailDatabase::GetFaviconBitmapIDSizes(
+bool ThumbnailDatabase::GetFaviconRawBitmapIDSizes(
     favicon_base::FaviconID icon_id,
-    std::vector<FaviconBitmapIDSize>* bitmap_id_sizes) {
+    std::vector<FaviconRawBitmapIDSize>* bitmap_id_sizes) {
   DCHECK(icon_id);
   sql::Statement statement(db_.GetCachedStatement(SQL_FROM_HERE,
       "SELECT id, width, height FROM favicon_bitmaps WHERE icon_id=?"));
   statement.BindInt64(0, icon_id);
 
   bool result = false;
   while (statement.Step()) {
     result = true;
     if (!bitmap_id_sizes)
       return result;
 
-    FaviconBitmapIDSize bitmap_id_size;
+    FaviconRawBitmapIDSize bitmap_id_size;
     bitmap_id_size.bitmap_id = statement.ColumnInt64(0);
     bitmap_id_size.pixel_size = gfx::Size(statement.ColumnInt(1),
                                           statement.ColumnInt(2));
     bitmap_id_sizes->push_back(bitmap_id_size);
   }
   return result;
 }
 
-bool ThumbnailDatabase::GetFaviconBitmaps(
+bool ThumbnailDatabase::GetFaviconRawBitmaps(
     favicon_base::FaviconID icon_id,
-    std::vector<FaviconBitmap>* favicon_bitmaps) {
+    std::vector<FaviconRawBitmap>* favicon_bitmaps) {
   DCHECK(icon_id);
   sql::Statement statement(db_.GetCachedStatement(SQL_FROM_HERE,
       "SELECT id, last_updated, image_data, width, height FROM favicon_bitmaps "
       "WHERE icon_id=?"));
   statement.BindInt64(0, icon_id);
 
   bool result = false;
   while (statement.Step()) {
     result = true;
     if (!favicon_bitmaps)
       return result;
 
-    FaviconBitmap favicon_bitmap;
+    FaviconRawBitmap favicon_bitmap;
     favicon_bitmap.bitmap_id = statement.ColumnInt64(0);
     favicon_bitmap.icon_id = icon_id;
     favicon_bitmap.last_updated =
         base::Time::FromInternalValue(statement.ColumnInt64(1));
     if (statement.ColumnByteLength(2) > 0) {
       scoped_refptr<base::RefCountedBytes> data(new base::RefCountedBytes());
       statement.ColumnBlobAsVector(2, &data->data());
       favicon_bitmap.bitmap_data = data;
     }
     favicon_bitmap.pixel_size = gfx::Size(statement.ColumnInt(3),
                                           statement.ColumnInt(4));
     favicon_bitmaps->push_back(favicon_bitmap);
   }
   return result;
 }
 
-bool ThumbnailDatabase::GetFaviconBitmap(
-    FaviconBitmapID bitmap_id,
+bool ThumbnailDatabase::GetFaviconRawBitmap(
+    FaviconRawBitmapID bitmap_id,
     base::Time* last_updated,
     scoped_refptr<base::RefCountedMemory>* png_icon_data,
     gfx::Size* pixel_size) {
   DCHECK(bitmap_id);
   sql::Statement statement(db_.GetCachedStatement(SQL_FROM_HERE,
       "SELECT last_updated, image_data, width, height FROM favicon_bitmaps "
       "WHERE id=?"));
   statement.BindInt64(0, bitmap_id);
 
   if (!statement.Step())
     return false;
 
   if (last_updated)
     *last_updated = base::Time::FromInternalValue(statement.ColumnInt64(0));
 
   if (png_icon_data && statement.ColumnByteLength(1) > 0) {
     scoped_refptr<base::RefCountedBytes> data(new base::RefCountedBytes());
     statement.ColumnBlobAsVector(1, &data->data());
     *png_icon_data = data;
   }
 
   if (pixel_size) {
     *pixel_size = gfx::Size(statement.ColumnInt(2),
                             statement.ColumnInt(3));
   }
   return true;
 }
 
-FaviconBitmapID ThumbnailDatabase::AddFaviconBitmap(
+FaviconRawBitmapID ThumbnailDatabase::AddFaviconRawBitmap(
     favicon_base::FaviconID icon_id,
     const scoped_refptr<base::RefCountedMemory>& icon_data,
     base::Time time,
     const gfx::Size& pixel_size) {
   DCHECK(icon_id);
   sql::Statement statement(db_.GetCachedStatement(SQL_FROM_HERE,
       "INSERT INTO favicon_bitmaps (icon_id, image_data, last_updated, width, "
       "height) VALUES (?, ?, ?, ?, ?)"));
   statement.BindInt64(0, icon_id);
   if (icon_data.get() && icon_data->size()) {
     statement.BindBlob(1, icon_data->front(),
                        static_cast<int>(icon_data->size()));
   } else {
     statement.BindNull(1);
   }
   statement.BindInt64(2, time.ToInternalValue());
   statement.BindInt(3, pixel_size.width());
   statement.BindInt(4, pixel_size.height());
 
   if (!statement.Run())
     return 0;
   return db_.GetLastInsertRowId();
 }
 
-bool ThumbnailDatabase::SetFaviconBitmap(
-    FaviconBitmapID bitmap_id,
+bool ThumbnailDatabase::SetFaviconRawBitmap(
+    FaviconRawBitmapID bitmap_id,
     scoped_refptr<base::RefCountedMemory> bitmap_data,
     base::Time time) {
   DCHECK(bitmap_id);
   sql::Statement statement(db_.GetCachedStatement(SQL_FROM_HERE,
       "UPDATE favicon_bitmaps SET image_data=?, last_updated=? WHERE id=?"));
   if (bitmap_data.get() && bitmap_data->size()) {
     statement.BindBlob(0, bitmap_data->front(),
                        static_cast<int>(bitmap_data->size()));
   } else {
     statement.BindNull(0);
   }
   statement.BindInt64(1, time.ToInternalValue());
   statement.BindInt64(2, bitmap_id);
 
   return statement.Run();
 }
 
-bool ThumbnailDatabase::SetFaviconBitmapLastUpdateTime(
-    FaviconBitmapID bitmap_id,
+bool ThumbnailDatabase::SetFaviconRawBitmapLastUpdateTime(
+    FaviconRawBitmapID bitmap_id,
     base::Time time) {
   DCHECK(bitmap_id);
   sql::Statement statement(db_.GetCachedStatement(SQL_FROM_HERE,
       "UPDATE favicon_bitmaps SET last_updated=? WHERE id=?"));
   statement.BindInt64(0, time.ToInternalValue());
   statement.BindInt64(1, bitmap_id);
   return statement.Run();
 }
 
-bool ThumbnailDatabase::DeleteFaviconBitmap(FaviconBitmapID bitmap_id) {
+bool ThumbnailDatabase::DeleteFaviconRawBitmap(FaviconRawBitmapID bitmap_id) {
   sql::Statement statement(db_.GetCachedStatement(SQL_FROM_HERE,
       "DELETE FROM favicon_bitmaps WHERE id=?"));
   statement.BindInt64(0, bitmap_id);
   return statement.Run();
 }
 
 bool ThumbnailDatabase::SetFaviconOutOfDate(favicon_base::FaviconID icon_id) {
   sql::Statement statement(db_.GetCachedStatement(SQL_FROM_HERE,
       "UPDATE favicon_bitmaps SET last_updated=? WHERE icon_id=?"));
   statement.BindInt64(0, 0);
@@ skipping 54 matching lines @@
   return db_.GetLastInsertRowId();
 }
 
 favicon_base::FaviconID ThumbnailDatabase::AddFavicon(
     const GURL& icon_url,
     favicon_base::IconType icon_type,
     const scoped_refptr<base::RefCountedMemory>& icon_data,
     base::Time time,
     const gfx::Size& pixel_size) {
   favicon_base::FaviconID icon_id = AddFavicon(icon_url, icon_type);
-  if (!icon_id || !AddFaviconBitmap(icon_id, icon_data, time, pixel_size))
+  if (!icon_id || !AddFaviconRawBitmap(icon_id, icon_data, time, pixel_size))
     return 0;
 
   return icon_id;
 }
 
 bool ThumbnailDatabase::DeleteFavicon(favicon_base::FaviconID id) {
   sql::Statement statement;
   statement.Assign(db_.GetCachedStatement(SQL_FROM_HERE,
       "DELETE FROM favicons WHERE id = ?"));
   statement.BindInt64(0, id);
@@ skipping 192 matching lines @@
   const char kRenameFaviconsTable[] =
       "ALTER TABLE favicons RENAME TO old_favicons";
   const char kCopyFavicons[] =
       "INSERT INTO favicons (id, url, icon_type) "
       "SELECT mapping.new_icon_id, old.url, old.icon_type "
       "FROM old_favicons AS old "
       "JOIN temp.icon_id_mapping AS mapping "
       "ON (old.id = mapping.old_icon_id)";
   const char kDropOldFaviconsTable[] = "DROP TABLE old_favicons";
 
-  const char kRenameFaviconBitmapsTable[] =
+  const char kRenameFaviconRawBitmapsTable[] =
       "ALTER TABLE favicon_bitmaps RENAME TO old_favicon_bitmaps";
-  const char kCopyFaviconBitmaps[] =
+  const char kCopyFaviconRawBitmaps[] =
       "INSERT INTO favicon_bitmaps "
       "  (icon_id, last_updated, image_data, width, height) "
       "SELECT mapping.new_icon_id, old.last_updated, "
       "    old.image_data, old.width, old.height "
       "FROM old_favicon_bitmaps AS old "
       "JOIN temp.icon_id_mapping AS mapping "
       "ON (old.icon_id = mapping.old_icon_id)";
-  const char kDropOldFaviconBitmapsTable[] =
+  const char kDropOldFaviconRawBitmapsTable[] =
       "DROP TABLE old_favicon_bitmaps";
 
   // Rename existing tables to new location.
   if (!db_.Execute(kRenameIconMappingTable) ||
       !db_.Execute(kRenameFaviconsTable) ||
-      !db_.Execute(kRenameFaviconBitmapsTable)) {
+      !db_.Execute(kRenameFaviconRawBitmapsTable)) {
     return false;
   }
 
   // Initialize the replacement tables.  At this point the old indices
   // still exist (pointing to the old_* tables), so do not initialize
   // the indices.
   if (!InitTables(&db_))
     return false;
 
   // Copy all of the data over.
-  if (!db_.Execute(kCopyIconMapping) ||
-      !db_.Execute(kCopyFavicons) ||
-      !db_.Execute(kCopyFaviconBitmaps)) {
+  if (!db_.Execute(kCopyIconMapping) || !db_.Execute(kCopyFavicons) ||
+      !db_.Execute(kCopyFaviconRawBitmaps)) {
     return false;
   }
 
   // Drop the old_* tables, which also drops the indices.
   if (!db_.Execute(kDropOldIconMappingTable) ||
       !db_.Execute(kDropOldFaviconsTable) ||
-      !db_.Execute(kDropOldFaviconBitmapsTable)) {
+      !db_.Execute(kDropOldFaviconRawBitmapsTable)) {
     return false;
   }
 
   // Recreate the indices.
   // TODO(shess): UNIQUE indices could fail due to duplication.  This
   // could happen in case of corruption.
   if (!InitIndices(&db_))
     return false;
 
   const char kIconMappingDrop[] = "DROP TABLE temp.icon_id_mapping";
@@ skipping 193 matching lines @@
   meta_table_.SetVersionNumber(7);
   meta_table_.SetCompatibleVersionNumber(std::min(7, kCompatibleVersionNumber));
   return true;
 }
 
 bool ThumbnailDatabase::IsFaviconDBStructureIncorrect() {
   return !db_.IsSQLValid("SELECT id, url, icon_type FROM favicons");
 }
 
 }  // namespace history