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())
@@ skipping 51 matching lines @@
   }
 
   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)) {
     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);
 }
 
 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,
@@ skipping 129 matching lines @@
   }
 
   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;
@@ skipping 125 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 35 matching lines @@
       ScheduleCommit();
     }
   }
 
   GetFaviconBitmapResultsForBestMatch(favicon_ids, desired_size_in_dip,
       desired_scale_factors, bitmap_results);
 }
 
 void HistoryBackend::SetFaviconBitmaps(
     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<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;
@@ skipping 22 matching lines @@
   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);
 
     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
@@ skipping 23 matching lines @@
                                   &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);
   UMA_HISTOGRAM_TIMES("History.GetFavIconFromDB",  // historical name
                       TimeTicks::Now() - beginning_time);
   return success && !favicon_bitmap_results->empty();
 }
 
 bool HistoryBackend::GetFaviconBitmapResultsForBestMatch(
     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
   // |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;
@@ skipping 21 matching lines @@
       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)) {
       return false;
     }
 
     bitmap_result.expired = (Time::Now() - last_updated) >
@@ skipping 582 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