Rename FaviconBitmapXxx to FaviconRawBitmapXxx

chrome/browser/history/history_backend.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/history_backend.h"
 
 #include <algorithm>
 #include <functional>
 #include <list>
 #include <map>
@@ skipping 1554 matching lines @@
   }
   UMA_HISTOGRAM_COUNTS("History.DeleteFTSIndexDatabases",
                        num_databases_deleted);
 }
 
 void HistoryBackend::GetFavicons(
     const std::vector<GURL>& icon_urls,
     int icon_types,
     int desired_size_in_dip,
     const std::vector<ui::ScaleFactor>& desired_scale_factors,
-    std::vector<favicon_base::FaviconBitmapResult>* bitmap_results) {
+    std::vector<favicon_base::FaviconRawBitmapResult>* bitmap_results) {
   UpdateFaviconMappingsAndFetchImpl(NULL, icon_urls, icon_types,
                                     desired_size_in_dip, desired_scale_factors,
                                     bitmap_results);
 }
 
 void HistoryBackend::GetLargestFaviconForURL(
     const GURL& page_url,
     const std::vector<int>& icon_types,
     int minimum_size_in_pixels,
-    favicon_base::FaviconBitmapResult* favicon_bitmap_result) {
+    favicon_base::FaviconRawBitmapResult* favicon_bitmap_result) {
   DCHECK(favicon_bitmap_result);
 
   if (!db_ || !thumbnail_db_)
     return;
 
   TimeTicks beginning_time = TimeTicks::Now();
 
   std::vector<IconMapping> icon_mappings;
   if (!thumbnail_db_->GetIconMappingsForPageURL(page_url, &icon_mappings) ||
       icon_mappings.empty())
     return;
 
   int required_icon_types = 0;
   for (std::vector<int>::const_iterator i = icon_types.begin();
        i != icon_types.end(); ++i) {
     required_icon_types |= *i;
   }
 
   // Find the largest bitmap for each IconType placing in
   // |largest_favicon_bitmaps|.
-  std::map<favicon_base::IconType, FaviconBitmap> largest_favicon_bitmaps;
+  std::map<favicon_base::IconType, FaviconRawBitmap> largest_favicon_bitmaps;
   for (std::vector<IconMapping>::const_iterator i = icon_mappings.begin();
        i != icon_mappings.end(); ++i) {
     if (!(i->icon_type & required_icon_types))
       continue;
-    std::vector<FaviconBitmapIDSize> bitmap_id_sizes;
-    thumbnail_db_->GetFaviconBitmapIDSizes(i->icon_id, &bitmap_id_sizes);
-    FaviconBitmap& largest = largest_favicon_bitmaps[i->icon_type];
-    for (std::vector<FaviconBitmapIDSize>::const_iterator j =
-             bitmap_id_sizes.begin(); j != bitmap_id_sizes.end(); ++j) {
+    std::vector<FaviconRawBitmapIDSize> bitmap_id_sizes;
+    thumbnail_db_->GetFaviconRawBitmapIDSizes(i->icon_id, &bitmap_id_sizes);
+    FaviconRawBitmap& largest = largest_favicon_bitmaps[i->icon_type];
+    for (std::vector<FaviconRawBitmapIDSize>::const_iterator j =
+             bitmap_id_sizes.begin();
+         j != bitmap_id_sizes.end();
+         ++j) {
       if (largest.bitmap_id == 0 ||
           (largest.pixel_size.width() < j->pixel_size.width() &&
            largest.pixel_size.height() < j->pixel_size.height())) {
         largest.icon_id = i->icon_id;
         largest.bitmap_id = j->bitmap_id;
         largest.pixel_size = j->pixel_size;
       }
     }
   }
   if (largest_favicon_bitmaps.empty())
     return;
 
   // Find an icon which is larger than minimum_size_in_pixels in the order of
   // icon_types.
-  FaviconBitmap largest_icon;
+  FaviconRawBitmap largest_icon;
   for (std::vector<int>::const_iterator t = icon_types.begin();
        t != icon_types.end(); ++t) {
-    for (std::map<favicon_base::IconType, FaviconBitmap>::const_iterator f =
+    for (std::map<favicon_base::IconType, FaviconRawBitmap>::const_iterator f =
              largest_favicon_bitmaps.begin();
          f != largest_favicon_bitmaps.end();
          ++f) {
       if (f->first & *t &&
           (largest_icon.bitmap_id == 0 ||
            (largest_icon.pixel_size.height() < f->second.pixel_size.height() &&
             largest_icon.pixel_size.width() < f->second.pixel_size.width()))) {
         largest_icon = f->second;
       }
     }
     if (largest_icon.pixel_size.width() > minimum_size_in_pixels &&
         largest_icon.pixel_size.height() > minimum_size_in_pixels)
       break;
   }
 
   GURL icon_url;
   favicon_base::IconType icon_type;
   if (!thumbnail_db_->GetFaviconHeader(largest_icon.icon_id, &icon_url,
                                        &icon_type)) {
     return;
   }
 
   base::Time last_updated;
-  favicon_base::FaviconBitmapResult bitmap_result;
+  favicon_base::FaviconRawBitmapResult bitmap_result;
   bitmap_result.icon_url = icon_url;
   bitmap_result.icon_type = icon_type;
-  if (!thumbnail_db_->GetFaviconBitmap(largest_icon.bitmap_id,
-                                       &last_updated,
-                                       &bitmap_result.bitmap_data,
-                                       &bitmap_result.pixel_size)) {
+  if (!thumbnail_db_->GetFaviconRawBitmap(largest_icon.bitmap_id,
+                                          &last_updated,
+                                          &bitmap_result.bitmap_data,
+                                          &bitmap_result.pixel_size)) {
     return;
   }
 
   bitmap_result.expired = (Time::Now() - last_updated) >
       TimeDelta::FromDays(kFaviconRefetchDays);
   if (bitmap_result.is_valid())
     *favicon_bitmap_result = bitmap_result;
 
   HISTOGRAM_TIMES("History.GetLargestFaviconForURL",
                   TimeTicks::Now() - beginning_time);
 }
 
 void HistoryBackend::GetFaviconsForURL(
     const GURL& page_url,
     int icon_types,
     int desired_size_in_dip,
     const std::vector<ui::ScaleFactor>& desired_scale_factors,
-    std::vector<favicon_base::FaviconBitmapResult>* bitmap_results) {
+    std::vector<favicon_base::FaviconRawBitmapResult>* bitmap_results) {
   DCHECK(bitmap_results);
   GetFaviconsFromDB(page_url, icon_types, desired_size_in_dip,
                     desired_scale_factors, bitmap_results);
 }
 
 void HistoryBackend::GetFaviconForID(
     favicon_base::FaviconID favicon_id,
     int desired_size_in_dip,
     ui::ScaleFactor desired_scale_factor,
-    std::vector<favicon_base::FaviconBitmapResult>* bitmap_results) {
+    std::vector<favicon_base::FaviconRawBitmapResult>* bitmap_results) {
   std::vector<favicon_base::FaviconID> favicon_ids;
   favicon_ids.push_back(favicon_id);
   std::vector<ui::ScaleFactor> desired_scale_factors;
   desired_scale_factors.push_back(desired_scale_factor);
 
   // Get results from DB.
-  GetFaviconBitmapResultsForBestMatch(favicon_ids,
-                                      desired_size_in_dip,
-                                      desired_scale_factors,
-                                      bitmap_results);
+  GetFaviconRawBitmapResultsForBestMatch(
+      favicon_ids, desired_size_in_dip, desired_scale_factors, bitmap_results);
 }
 
 void HistoryBackend::UpdateFaviconMappingsAndFetch(
     const GURL& page_url,
     const std::vector<GURL>& icon_urls,
     int icon_types,
     int desired_size_in_dip,
     const std::vector<ui::ScaleFactor>& desired_scale_factors,
-    std::vector<favicon_base::FaviconBitmapResult>* bitmap_results) {
+    std::vector<favicon_base::FaviconRawBitmapResult>* bitmap_results) {
   UpdateFaviconMappingsAndFetchImpl(&page_url, icon_urls, icon_types,
                                     desired_size_in_dip, desired_scale_factors,
                                     bitmap_results);
 }
 
 void HistoryBackend::MergeFavicon(
     const GURL& page_url,
     const GURL& icon_url,
     favicon_base::IconType icon_type,
     scoped_refptr<base::RefCountedMemory> bitmap_data,
     const gfx::Size& pixel_size) {
   if (!thumbnail_db_ || !db_)
     return;
 
   favicon_base::FaviconID favicon_id =
       thumbnail_db_->GetFaviconIDForFaviconURL(icon_url, icon_type, NULL);
 
   if (!favicon_id) {
     // There is no favicon at |icon_url|, create it.
     favicon_id = thumbnail_db_->AddFavicon(icon_url, icon_type);
   }
 
-  std::vector<FaviconBitmapIDSize> bitmap_id_sizes;
-  thumbnail_db_->GetFaviconBitmapIDSizes(favicon_id, &bitmap_id_sizes);
+  std::vector<FaviconRawBitmapIDSize> bitmap_id_sizes;
+  thumbnail_db_->GetFaviconRawBitmapIDSizes(favicon_id, &bitmap_id_sizes);
 
   // If there is already a favicon bitmap of |pixel_size| at |icon_url|,
   // replace it.
   bool bitmap_identical = false;
   bool replaced_bitmap = false;
   for (size_t i = 0; i < bitmap_id_sizes.size(); ++i) {
     if (bitmap_id_sizes[i].pixel_size == pixel_size) {
-      if (IsFaviconBitmapDataEqual(bitmap_id_sizes[i].bitmap_id, bitmap_data)) {
-        thumbnail_db_->SetFaviconBitmapLastUpdateTime(
+      if (IsFaviconRawBitmapDataEqual(bitmap_id_sizes[i].bitmap_id,
+                                      bitmap_data)) {
+        thumbnail_db_->SetFaviconRawBitmapLastUpdateTime(
             bitmap_id_sizes[i].bitmap_id, base::Time::Now());
         bitmap_identical = true;
       } else {
-        thumbnail_db_->SetFaviconBitmap(bitmap_id_sizes[i].bitmap_id,
-            bitmap_data, base::Time::Now());
+        thumbnail_db_->SetFaviconRawBitmap(
+            bitmap_id_sizes[i].bitmap_id, bitmap_data, base::Time::Now());
         replaced_bitmap = true;
       }
       break;
     }
   }
 
   // Create a vector of the pixel sizes of the favicon bitmaps currently at
   // |icon_url|.
   std::vector<gfx::Size> favicon_sizes;
   for (size_t i = 0; i < bitmap_id_sizes.size(); ++i)
     favicon_sizes.push_back(bitmap_id_sizes[i].pixel_size);
 
   if (!replaced_bitmap && !bitmap_identical) {
     // Set the preexisting favicon bitmaps as expired as the preexisting favicon
     // bitmaps are not consistent with the merged in data.
     thumbnail_db_->SetFaviconOutOfDate(favicon_id);
 
     // Delete an arbitrary favicon bitmap to avoid going over the limit of
-    // |kMaxFaviconBitmapsPerIconURL|.
-    if (bitmap_id_sizes.size() >= kMaxFaviconBitmapsPerIconURL) {
-      thumbnail_db_->DeleteFaviconBitmap(bitmap_id_sizes[0].bitmap_id);
+    // |kMaxFaviconRawBitmapsPerIconURL|.
+    if (bitmap_id_sizes.size() >= kMaxFaviconRawBitmapsPerIconURL) {
+      thumbnail_db_->DeleteFaviconRawBitmap(bitmap_id_sizes[0].bitmap_id);
       favicon_sizes.erase(favicon_sizes.begin());
     }
-    thumbnail_db_->AddFaviconBitmap(favicon_id, bitmap_data, base::Time::Now(),
-                                    pixel_size);
+    thumbnail_db_->AddFaviconRawBitmap(
+        favicon_id, bitmap_data, base::Time::Now(), pixel_size);
     favicon_sizes.push_back(pixel_size);
   }
 
   // A site may have changed the favicons that it uses for |page_url|.
   // Example Scenario:
   //   page_url = news.google.com
   //   Initial State: www.google.com/favicon.ico 16x16, 32x32
   //   MergeFavicon(news.google.com, news.google.com/news_specific.ico, ...,
   //                ..., 16x16)
   //
@@ skipping 15 matching lines @@
   // / incorrect data.
   // Difficulty 1: All but news.google.com/news_specific.ico are unmapped from
   //              news.google.com
   // Difficulty 2: The favicon bitmaps for www.google.com/favicon.ico are not
   //               modified.
 
   std::vector<IconMapping> icon_mappings;
   thumbnail_db_->GetIconMappingsForPageURL(page_url, icon_type, &icon_mappings);
 
   // Copy the favicon bitmaps mapped to |page_url| to the favicon at |icon_url|
-  // till the limit of |kMaxFaviconBitmapsPerIconURL| is reached.
+  // till the limit of |kMaxFaviconRawBitmapsPerIconURL| is reached.
   for (size_t i = 0; i < icon_mappings.size(); ++i) {
-    if (favicon_sizes.size() >= kMaxFaviconBitmapsPerIconURL)
+    if (favicon_sizes.size() >= kMaxFaviconRawBitmapsPerIconURL)
       break;
 
     if (icon_mappings[i].icon_url == icon_url)
       continue;
 
-    std::vector<FaviconBitmap> bitmaps_to_copy;
-    thumbnail_db_->GetFaviconBitmaps(icon_mappings[i].icon_id,
-                                     &bitmaps_to_copy);
+    std::vector<FaviconRawBitmap> bitmaps_to_copy;
+    thumbnail_db_->GetFaviconRawBitmaps(icon_mappings[i].icon_id,
+                                        &bitmaps_to_copy);
     for (size_t j = 0; j < bitmaps_to_copy.size(); ++j) {
       // Do not add a favicon bitmap at a pixel size for which there is already
       // a favicon bitmap mapped to |icon_url|. The one there is more correct
       // and having multiple equally sized favicon bitmaps for |page_url| is
       // ambiguous in terms of GetFaviconsForURL().
       std::vector<gfx::Size>::iterator it = std::find(favicon_sizes.begin(),
           favicon_sizes.end(), bitmaps_to_copy[j].pixel_size);
       if (it != favicon_sizes.end())
         continue;
 
       // Add the favicon bitmap as expired as it is not consistent with the
       // merged in data.
-      thumbnail_db_->AddFaviconBitmap(favicon_id,
-          bitmaps_to_copy[j].bitmap_data, base::Time(),
-          bitmaps_to_copy[j].pixel_size);
+      thumbnail_db_->AddFaviconRawBitmap(favicon_id,
+                                         bitmaps_to_copy[j].bitmap_data,
+                                         base::Time(),
+                                         bitmaps_to_copy[j].pixel_size);
       favicon_sizes.push_back(bitmaps_to_copy[j].pixel_size);
 
-      if (favicon_sizes.size() >= kMaxFaviconBitmapsPerIconURL)
+      if (favicon_sizes.size() >= kMaxFaviconRawBitmapsPerIconURL)
         break;
     }
   }
 
   // Update the favicon mappings such that only |icon_url| is mapped to
   // |page_url|.
   bool mapping_changed = false;
   if (icon_mappings.size() != 1 || icon_mappings[0].icon_url != icon_url) {
     std::vector<favicon_base::FaviconID> favicon_ids;
     favicon_ids.push_back(favicon_id);
     SetFaviconMappingsForPageAndRedirects(page_url, icon_type, favicon_ids);
     mapping_changed = true;
   }
 
   if (mapping_changed || !bitmap_identical)
     SendFaviconChangedNotificationForPageAndRedirects(page_url);
   ScheduleCommit();
 }
 
 void HistoryBackend::SetFavicons(
     const GURL& page_url,
     favicon_base::IconType icon_type,
-    const std::vector<favicon_base::FaviconBitmapData>& favicon_bitmap_data) {
+    const std::vector<favicon_base::FaviconRawBitmapData>&
+        favicon_bitmap_data) {
   if (!thumbnail_db_ || !db_)
     return;
 
   DCHECK(ValidateSetFaviconsParams(favicon_bitmap_data));
 
-  // Build map of FaviconBitmapData for each icon url.
-  typedef std::map<GURL, std::vector<favicon_base::FaviconBitmapData> >
+  // Build map of FaviconRawBitmapData for each icon url.
+  typedef std::map<GURL, std::vector<favicon_base::FaviconRawBitmapData> >
       BitmapDataByIconURL;
   BitmapDataByIconURL grouped_by_icon_url;
   for (size_t i = 0; i < favicon_bitmap_data.size(); ++i) {
     const GURL& icon_url = favicon_bitmap_data[i].icon_url;
     grouped_by_icon_url[icon_url].push_back(favicon_bitmap_data[i]);
   }
 
   // Track whether the method modifies or creates any favicon bitmaps, favicons
   // or icon mappings.
   bool data_modified = false;
 
   std::vector<favicon_base::FaviconID> icon_ids;
   for (BitmapDataByIconURL::const_iterator it = grouped_by_icon_url.begin();
        it != grouped_by_icon_url.end(); ++it) {
     const GURL& icon_url = it->first;
     favicon_base::FaviconID icon_id =
         thumbnail_db_->GetFaviconIDForFaviconURL(icon_url, icon_type, NULL);
 
     if (!icon_id) {
       // TODO(pkotwicz): Remove the favicon sizes attribute from
       // ThumbnailDatabase::AddFavicon().
       icon_id = thumbnail_db_->AddFavicon(icon_url, icon_type);
       data_modified = true;
     }
     icon_ids.push_back(icon_id);
 
     if (!data_modified)
-      SetFaviconBitmaps(icon_id, it->second, &data_modified);
+      SetFaviconRawBitmaps(icon_id, it->second, &data_modified);
     else
-      SetFaviconBitmaps(icon_id, it->second, NULL);
+      SetFaviconRawBitmaps(icon_id, it->second, NULL);
   }
 
   data_modified |=
     SetFaviconMappingsForPageAndRedirects(page_url, icon_type, icon_ids);
 
   if (data_modified) {
     // Send notification to the UI as an icon mapping, favicon, or favicon
     // bitmap was changed by this function.
     SendFaviconChangedNotificationForPageAndRedirects(page_url);
   }
@@ skipping 95 matching lines @@
                            changed_details.PassAs<HistoryDetails>());
   }
 }
 
 void HistoryBackend::UpdateFaviconMappingsAndFetchImpl(
     const GURL* page_url,
     const std::vector<GURL>& icon_urls,
     int icon_types,
     int desired_size_in_dip,
     const std::vector<ui::ScaleFactor>& desired_scale_factors,
-    std::vector<favicon_base::FaviconBitmapResult>* bitmap_results) {
+    std::vector<favicon_base::FaviconRawBitmapResult>* bitmap_results) {
   // If |page_url| is specified, |icon_types| must be either a single icon
   // type or icon types which are equivalent.
   DCHECK(!page_url || icon_types == favicon_base::FAVICON ||
          icon_types == favicon_base::TOUCH_ICON ||
          icon_types == favicon_base::TOUCH_PRECOMPOSED_ICON ||
          icon_types ==
              (favicon_base::TOUCH_ICON | favicon_base::TOUCH_PRECOMPOSED_ICON));
   bitmap_results->clear();
 
   if (!thumbnail_db_) {
@@ skipping 29 matching lines @@
   if (page_url && !favicon_ids.empty()) {
     bool mappings_updated =
         SetFaviconMappingsForPageAndRedirects(*page_url, selected_icon_type,
                                               favicon_ids);
     if (mappings_updated) {
       SendFaviconChangedNotificationForPageAndRedirects(*page_url);
       ScheduleCommit();
     }
   }
 
-  GetFaviconBitmapResultsForBestMatch(favicon_ids, desired_size_in_dip,
-      desired_scale_factors, bitmap_results);
+  GetFaviconRawBitmapResultsForBestMatch(
+      favicon_ids, desired_size_in_dip, desired_scale_factors, bitmap_results);
 }
 
-void HistoryBackend::SetFaviconBitmaps(
+void HistoryBackend::SetFaviconRawBitmaps(
     favicon_base::FaviconID icon_id,
-    const std::vector<favicon_base::FaviconBitmapData>& favicon_bitmap_data,
+    const std::vector<favicon_base::FaviconRawBitmapData>& favicon_bitmap_data,
     bool* favicon_bitmaps_changed) {
   if (favicon_bitmaps_changed)
     *favicon_bitmaps_changed = false;
 
-  std::vector<FaviconBitmapIDSize> bitmap_id_sizes;
-  thumbnail_db_->GetFaviconBitmapIDSizes(icon_id, &bitmap_id_sizes);
+  std::vector<FaviconRawBitmapIDSize> bitmap_id_sizes;
+  thumbnail_db_->GetFaviconRawBitmapIDSizes(icon_id, &bitmap_id_sizes);
 
-  std::vector<favicon_base::FaviconBitmapData> to_add = favicon_bitmap_data;
+  std::vector<favicon_base::FaviconRawBitmapData> to_add = favicon_bitmap_data;
 
   for (size_t i = 0; i < bitmap_id_sizes.size(); ++i) {
     const gfx::Size& pixel_size = bitmap_id_sizes[i].pixel_size;
-    std::vector<favicon_base::FaviconBitmapData>::iterator match_it =
+    std::vector<favicon_base::FaviconRawBitmapData>::iterator match_it =
         to_add.end();
-    for (std::vector<favicon_base::FaviconBitmapData>::iterator it =
+    for (std::vector<favicon_base::FaviconRawBitmapData>::iterator it =
              to_add.begin();
          it != to_add.end();
          ++it) {
       if (it->pixel_size == pixel_size) {
         match_it = it;
         break;
       }
     }
 
-    FaviconBitmapID bitmap_id = bitmap_id_sizes[i].bitmap_id;
+    FaviconRawBitmapID bitmap_id = bitmap_id_sizes[i].bitmap_id;
     if (match_it == to_add.end()) {
-      thumbnail_db_->DeleteFaviconBitmap(bitmap_id);
+      thumbnail_db_->DeleteFaviconRawBitmap(bitmap_id);
 
       if (favicon_bitmaps_changed)
         *favicon_bitmaps_changed = true;
     } else {
-      if (favicon_bitmaps_changed &&
-          !*favicon_bitmaps_changed &&
-          IsFaviconBitmapDataEqual(bitmap_id, match_it->bitmap_data)) {
-        thumbnail_db_->SetFaviconBitmapLastUpdateTime(
-            bitmap_id, base::Time::Now());
+      if (favicon_bitmaps_changed && !*favicon_bitmaps_changed &&
+          IsFaviconRawBitmapDataEqual(bitmap_id, match_it->bitmap_data)) {
+        thumbnail_db_->SetFaviconRawBitmapLastUpdateTime(bitmap_id,
+                                                         base::Time::Now());
       } else {
-        thumbnail_db_->SetFaviconBitmap(bitmap_id, match_it->bitmap_data,
-            base::Time::Now());
+        thumbnail_db_->SetFaviconRawBitmap(
+            bitmap_id, match_it->bitmap_data, base::Time::Now());
 
         if (favicon_bitmaps_changed)
           *favicon_bitmaps_changed = true;
       }
       to_add.erase(match_it);
     }
   }
 
   for (size_t i = 0; i < to_add.size(); ++i) {
-    thumbnail_db_->AddFaviconBitmap(icon_id, to_add[i].bitmap_data,
-        base::Time::Now(), to_add[i].pixel_size);
+    thumbnail_db_->AddFaviconRawBitmap(icon_id,
+                                       to_add[i].bitmap_data,
+                                       base::Time::Now(),
+                                       to_add[i].pixel_size);
 
     if (favicon_bitmaps_changed)
       *favicon_bitmaps_changed = true;
   }
 }
 
 bool HistoryBackend::ValidateSetFaviconsParams(const std::vector<
-    favicon_base::FaviconBitmapData>& favicon_bitmap_data) const {
+    favicon_base::FaviconRawBitmapData>& favicon_bitmap_data) const {
   typedef std::map<GURL, size_t> BitmapsPerIconURL;
   BitmapsPerIconURL num_bitmaps_per_icon_url;
   for (size_t i = 0; i < favicon_bitmap_data.size(); ++i) {
     if (!favicon_bitmap_data[i].bitmap_data.get())
       return false;
 
     const GURL& icon_url = favicon_bitmap_data[i].icon_url;
     if (!num_bitmaps_per_icon_url.count(icon_url))
       num_bitmaps_per_icon_url[icon_url] = 1u;
     else
       ++num_bitmaps_per_icon_url[icon_url];
   }
 
   if (num_bitmaps_per_icon_url.size() > kMaxFaviconsPerPage)
     return false;
 
   for (BitmapsPerIconURL::const_iterator it = num_bitmaps_per_icon_url.begin();
        it != num_bitmaps_per_icon_url.end(); ++it) {
-    if (it->second > kMaxFaviconBitmapsPerIconURL)
+    if (it->second > kMaxFaviconRawBitmapsPerIconURL)
       return false;
   }
   return true;
 }
 
-bool HistoryBackend::IsFaviconBitmapDataEqual(
-    FaviconBitmapID bitmap_id,
+bool HistoryBackend::IsFaviconRawBitmapDataEqual(
+    FaviconRawBitmapID bitmap_id,
     const scoped_refptr<base::RefCountedMemory>& new_bitmap_data) {
   if (!new_bitmap_data.get())
     return false;
 
   scoped_refptr<base::RefCountedMemory> original_bitmap_data;
-  thumbnail_db_->GetFaviconBitmap(bitmap_id,
-                                  NULL,
-                                  &original_bitmap_data,
-                                  NULL);
+  thumbnail_db_->GetFaviconRawBitmap(
+      bitmap_id, NULL, &original_bitmap_data, NULL);
   return new_bitmap_data->Equals(original_bitmap_data);
 }
 
 bool HistoryBackend::GetFaviconsFromDB(
     const GURL& page_url,
     int icon_types,
     int desired_size_in_dip,
     const std::vector<ui::ScaleFactor>& desired_scale_factors,
-    std::vector<favicon_base::FaviconBitmapResult>* favicon_bitmap_results) {
+    std::vector<favicon_base::FaviconRawBitmapResult>* favicon_bitmap_results) {
   DCHECK(favicon_bitmap_results);
   favicon_bitmap_results->clear();
 
   if (!db_ || !thumbnail_db_)
     return false;
 
   // Time the query.
   TimeTicks beginning_time = TimeTicks::Now();
 
   // Get FaviconIDs for |page_url| and one of |icon_types|.
   std::vector<IconMapping> icon_mappings;
   thumbnail_db_->GetIconMappingsForPageURL(page_url, icon_types,
                                            &icon_mappings);
   std::vector<favicon_base::FaviconID> favicon_ids;
   for (size_t i = 0; i < icon_mappings.size(); ++i)
     favicon_ids.push_back(icon_mappings[i].icon_id);
 
   // Populate |favicon_bitmap_results| and |icon_url_sizes|.
-  bool success = GetFaviconBitmapResultsForBestMatch(favicon_ids,
-      desired_size_in_dip, desired_scale_factors, favicon_bitmap_results);
+  bool success = GetFaviconRawBitmapResultsForBestMatch(favicon_ids,
+                                                        desired_size_in_dip,
+                                                        desired_scale_factors,
+                                                        favicon_bitmap_results);
   UMA_HISTOGRAM_TIMES("History.GetFavIconFromDB",  // historical name
                       TimeTicks::Now() - beginning_time);
   return success && !favicon_bitmap_results->empty();
 }
 
-bool HistoryBackend::GetFaviconBitmapResultsForBestMatch(
+bool HistoryBackend::GetFaviconRawBitmapResultsForBestMatch(
     const std::vector<favicon_base::FaviconID>& candidate_favicon_ids,
     int desired_size_in_dip,
     const std::vector<ui::ScaleFactor>& desired_scale_factors,
-    std::vector<favicon_base::FaviconBitmapResult>* favicon_bitmap_results) {
+    std::vector<favicon_base::FaviconRawBitmapResult>* favicon_bitmap_results) {
   favicon_bitmap_results->clear();
 
   if (candidate_favicon_ids.empty())
     return true;
 
-  // Find the FaviconID and the FaviconBitmapIDs which best match
+  // Find the FaviconID and the FaviconRawBitmapIDs which best match
   // |desired_size_in_dip| and |desired_scale_factors|.
   // TODO(pkotwicz): Select bitmap results from multiple favicons once
   // content::FaviconStatus supports multiple icon URLs.
   favicon_base::FaviconID best_favicon_id = 0;
-  std::vector<FaviconBitmapID> best_bitmap_ids;
+  std::vector<FaviconRawBitmapID> best_bitmap_ids;
   float highest_score = kSelectFaviconFramesInvalidScore;
   for (size_t i = 0; i < candidate_favicon_ids.size(); ++i) {
-    std::vector<FaviconBitmapIDSize> bitmap_id_sizes;
-    thumbnail_db_->GetFaviconBitmapIDSizes(candidate_favicon_ids[i],
-                                           &bitmap_id_sizes);
+    std::vector<FaviconRawBitmapIDSize> bitmap_id_sizes;
+    thumbnail_db_->GetFaviconRawBitmapIDSizes(candidate_favicon_ids[i],
+                                              &bitmap_id_sizes);
 
     // Build vector of gfx::Size from |bitmap_id_sizes|.
     std::vector<gfx::Size> sizes;
     for (size_t j = 0; j < bitmap_id_sizes.size(); ++j)
       sizes.push_back(bitmap_id_sizes[j].pixel_size);
 
     std::vector<size_t> candidate_bitmap_indices;
     float score = 0;
     SelectFaviconFrameIndices(sizes,
                               desired_scale_factors,
                               desired_size_in_dip,
                               &candidate_bitmap_indices,
                               &score);
     if (score > highest_score) {
       highest_score = score;
       best_favicon_id = candidate_favicon_ids[i],
       best_bitmap_ids.clear();
       for (size_t j = 0; j < candidate_bitmap_indices.size(); ++j) {
         size_t candidate_index = candidate_bitmap_indices[j];
         best_bitmap_ids.push_back(
             bitmap_id_sizes[candidate_index].bitmap_id);
       }
     }
   }
 
-  // Construct FaviconBitmapResults from |best_favicon_id| and
+  // Construct FaviconRawBitmapResults from |best_favicon_id| and
   // |best_bitmap_ids|.
   GURL icon_url;
   favicon_base::IconType icon_type;
   if (!thumbnail_db_->GetFaviconHeader(best_favicon_id, &icon_url,
                                        &icon_type)) {
     return false;
   }
 
   for (size_t i = 0; i < best_bitmap_ids.size(); ++i) {
     base::Time last_updated;
-    favicon_base::FaviconBitmapResult bitmap_result;
+    favicon_base::FaviconRawBitmapResult bitmap_result;
     bitmap_result.icon_url = icon_url;
     bitmap_result.icon_type = icon_type;
-    if (!thumbnail_db_->GetFaviconBitmap(best_bitmap_ids[i],
-                                         &last_updated,
-                                         &bitmap_result.bitmap_data,
-                                         &bitmap_result.pixel_size)) {
+    if (!thumbnail_db_->GetFaviconRawBitmap(best_bitmap_ids[i],
+                                            &last_updated,
+                                            &bitmap_result.bitmap_data,
+                                            &bitmap_result.pixel_size)) {
       return false;
     }
 
     bitmap_result.expired = (Time::Now() - last_updated) >
         TimeDelta::FromDays(kFaviconRefetchDays);
     if (bitmap_result.is_valid())
       favicon_bitmap_results->push_back(bitmap_result);
   }
   return true;
 }
@@ skipping 576 matching lines @@
   int rank = kPageVisitStatsMaxTopSites;
   std::map<GURL, int>::const_iterator it = most_visited_urls_map_.find(url);
   if (it != most_visited_urls_map_.end())
     rank = (*it).second;
   UMA_HISTOGRAM_ENUMERATION("History.TopSitesVisitsByRank",
                             rank, kPageVisitStatsMaxTopSites + 1);
 }
 #endif
 
 }  // namespace history