Rename FaviconBitmapXxx to FaviconRawBitmapXxx

chrome/browser/history/history_backend_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 "chrome/browser/history/history_backend.h"
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
@@ skipping 35 matching lines @@
 // history unit test. Because of the elaborate callbacks involved, this is no
 // harder than calling it directly for many things.
 
 namespace {
 
 static const gfx::Size kTinySize = gfx::Size(10, 10);
 static const gfx::Size kSmallSize = gfx::Size(16, 16);
 static const gfx::Size kLargeSize = gfx::Size(32, 32);
 
 // Comparison functions as to make it easier to check results of
-// GetFaviconBitmaps() and GetIconMappingsForPageURL().
+// GetFaviconRawBitmaps() and GetIconMappingsForPageURL().
 bool IconMappingLessThan(const history::IconMapping& a,
                          const history::IconMapping& b) {
   return a.icon_url < b.icon_url;
 }
 
-bool FaviconBitmapLessThan(const history::FaviconBitmap& a,
-                           const history::FaviconBitmap& b) {
+bool FaviconRawBitmapLessThan(const history::FaviconRawBitmap& a,
+                              const history::FaviconRawBitmap& b) {
   return a.pixel_size.GetArea() < b.pixel_size.GetArea();
 }
 
 class HistoryClientMock : public history::HistoryClientFakeBookmarks {
  public:
   MOCK_METHOD0(BlockUntilBookmarksLoaded, void());
 };
 
 }  // namespace
 
@@ skipping 279 matching lines @@
         icon_mappings)) {
       return false;
     }
     std::sort(icon_mappings->begin(), icon_mappings->end(),
               IconMappingLessThan);
     return true;
   }
 
   // Returns the favicon bitmaps for |icon_id| sorted by pixel size in
   // ascending order. Returns true if there is at least one favicon bitmap.
-  bool GetSortedFaviconBitmaps(favicon_base::FaviconID icon_id,
-                               std::vector<FaviconBitmap>* favicon_bitmaps) {
-    if (!backend_->thumbnail_db_->GetFaviconBitmaps(icon_id, favicon_bitmaps))
+  bool GetSortedFaviconRawBitmaps(
+      favicon_base::FaviconID icon_id,
+      std::vector<FaviconRawBitmap>* favicon_bitmaps) {
+    if (!backend_->thumbnail_db_->GetFaviconRawBitmaps(icon_id,
+                                                       favicon_bitmaps))
       return false;
-    std::sort(favicon_bitmaps->begin(), favicon_bitmaps->end(),
-              FaviconBitmapLessThan);
+    std::sort(favicon_bitmaps->begin(),
+              favicon_bitmaps->end(),
+              FaviconRawBitmapLessThan);
     return true;
   }
 
   // Returns true if there is exactly one favicon bitmap associated to
   // |favicon_id|. If true, returns favicon bitmap in output parameter.
-  bool GetOnlyFaviconBitmap(const favicon_base::FaviconID icon_id,
-                            FaviconBitmap* favicon_bitmap) {
-    std::vector<FaviconBitmap> favicon_bitmaps;
-    if (!backend_->thumbnail_db_->GetFaviconBitmaps(icon_id, &favicon_bitmaps))
+  bool GetOnlyFaviconRawBitmap(const favicon_base::FaviconID icon_id,
+                               FaviconRawBitmap* favicon_bitmap) {
+    std::vector<FaviconRawBitmap> favicon_bitmaps;
+    if (!backend_->thumbnail_db_->GetFaviconRawBitmaps(icon_id,
+                                                       &favicon_bitmaps))
       return false;
     if (favicon_bitmaps.size() != 1)
       return false;
     *favicon_bitmap = favicon_bitmaps[0];
     return true;
   }
 
   // Generates |favicon_bitmap_data| with entries for the icon_urls and sizes
   // specified. The bitmap_data for entries are lowercase letters of the
   // alphabet starting at 'a' for the entry at index 0.
-  void GenerateFaviconBitmapData(
+  void GenerateFaviconRawBitmapData(
       const GURL& icon_url1,
       const std::vector<gfx::Size>& icon_url1_sizes,
-      std::vector<favicon_base::FaviconBitmapData>* favicon_bitmap_data) {
-    GenerateFaviconBitmapData(icon_url1, icon_url1_sizes, GURL(),
-                              std::vector<gfx::Size>(), favicon_bitmap_data);
+      std::vector<favicon_base::FaviconRawBitmapData>* favicon_bitmap_data) {
+    GenerateFaviconRawBitmapData(icon_url1,
+                                 icon_url1_sizes,
+                                 GURL(),
+                                 std::vector<gfx::Size>(),
+                                 favicon_bitmap_data);
   }
 
-  void GenerateFaviconBitmapData(
+  void GenerateFaviconRawBitmapData(
       const GURL& icon_url1,
       const std::vector<gfx::Size>& icon_url1_sizes,
       const GURL& icon_url2,
       const std::vector<gfx::Size>& icon_url2_sizes,
-      std::vector<favicon_base::FaviconBitmapData>* favicon_bitmap_data) {
+      std::vector<favicon_base::FaviconRawBitmapData>* favicon_bitmap_data) {
     favicon_bitmap_data->clear();
 
     char bitmap_char = 'a';
     for (size_t i = 0; i < icon_url1_sizes.size(); ++i) {
       std::vector<unsigned char> data;
       data.push_back(bitmap_char);
-      favicon_base::FaviconBitmapData bitmap_data_element;
+      favicon_base::FaviconRawBitmapData bitmap_data_element;
       bitmap_data_element.bitmap_data =
           base::RefCountedBytes::TakeVector(&data);
       bitmap_data_element.pixel_size = icon_url1_sizes[i];
       bitmap_data_element.icon_url = icon_url1;
       favicon_bitmap_data->push_back(bitmap_data_element);
 
       ++bitmap_char;
     }
 
     for (size_t i = 0; i < icon_url2_sizes.size(); ++i) {
       std::vector<unsigned char> data;
       data.push_back(bitmap_char);
-      favicon_base::FaviconBitmapData bitmap_data_element;
+      favicon_base::FaviconRawBitmapData bitmap_data_element;
       bitmap_data_element.bitmap_data =
           base::RefCountedBytes::TakeVector(&data);
       bitmap_data_element.pixel_size = icon_url2_sizes[i];
       bitmap_data_element.icon_url = icon_url2;
       favicon_bitmap_data->push_back(bitmap_data_element);
 
       ++bitmap_char;
     }
   }
 
@@ skipping 122 matching lines @@
   // we can test that updating works properly.
   GURL favicon_url1("http://www.google.com/favicon.ico");
   GURL favicon_url2("http://news.google.com/favicon.ico");
   favicon_base::FaviconID favicon2 =
       backend_->thumbnail_db_->AddFavicon(favicon_url2, favicon_base::FAVICON);
   favicon_base::FaviconID favicon1 =
       backend_->thumbnail_db_->AddFavicon(favicon_url1, favicon_base::FAVICON);
 
   std::vector<unsigned char> data;
   data.push_back('a');
-  EXPECT_TRUE(backend_->thumbnail_db_->AddFaviconBitmap(favicon1,
-      new base::RefCountedBytes(data), Time::Now(), kSmallSize));
+  EXPECT_TRUE(backend_->thumbnail_db_->AddFaviconRawBitmap(
+      favicon1, new base::RefCountedBytes(data), Time::Now(), kSmallSize));
   data[0] = 'b';
-  EXPECT_TRUE(backend_->thumbnail_db_->AddFaviconBitmap(favicon1,
-     new base::RefCountedBytes(data), Time::Now(), kLargeSize));
+  EXPECT_TRUE(backend_->thumbnail_db_->AddFaviconRawBitmap(
+      favicon1, new base::RefCountedBytes(data), Time::Now(), kLargeSize));
 
   data[0] = 'c';
-  EXPECT_TRUE(backend_->thumbnail_db_->AddFaviconBitmap(favicon2,
-      new base::RefCountedBytes(data), Time::Now(), kSmallSize));
+  EXPECT_TRUE(backend_->thumbnail_db_->AddFaviconRawBitmap(
+      favicon2, new base::RefCountedBytes(data), Time::Now(), kSmallSize));
   data[0] = 'd';
-  EXPECT_TRUE(backend_->thumbnail_db_->AddFaviconBitmap(favicon2,
-     new base::RefCountedBytes(data), Time::Now(), kLargeSize));
+  EXPECT_TRUE(backend_->thumbnail_db_->AddFaviconRawBitmap(
+      favicon2, new base::RefCountedBytes(data), Time::Now(), kLargeSize));
 
   // First visit two URLs.
   URLRow row1(GURL("http://www.google.com/"));
   row1.set_visit_count(2);
   row1.set_typed_count(1);
   row1.set_last_visit(Time::Now());
   backend_->thumbnail_db_->AddIconMapping(row1.url(), favicon1);
 
   URLRow row2(GURL("http://news.google.com/"));
   row2.set_visit_count(1);
@@ skipping 46 matching lines @@
   backend_->db_->GetAllVisitsInRange(Time(), Time(), 0, &all_visits);
   ASSERT_EQ(0U, all_visits.size());
 
   // We should have a favicon and favicon bitmaps for the first URL only. We
   // look them up by favicon URL since the IDs may have changed.
   favicon_base::FaviconID out_favicon1 =
       backend_->thumbnail_db_->GetFaviconIDForFaviconURL(
           favicon_url1, favicon_base::FAVICON, NULL);
   EXPECT_TRUE(out_favicon1);
 
-  std::vector<FaviconBitmap> favicon_bitmaps;
-  EXPECT_TRUE(backend_->thumbnail_db_->GetFaviconBitmaps(
-      out_favicon1, &favicon_bitmaps));
+  std::vector<FaviconRawBitmap> favicon_bitmaps;
+  EXPECT_TRUE(backend_->thumbnail_db_->GetFaviconRawBitmaps(out_favicon1,
+                                                            &favicon_bitmaps));
   ASSERT_EQ(2u, favicon_bitmaps.size());
 
-  FaviconBitmap favicon_bitmap1 = favicon_bitmaps[0];
-  FaviconBitmap favicon_bitmap2 = favicon_bitmaps[1];
+  FaviconRawBitmap favicon_bitmap1 = favicon_bitmaps[0];
+  FaviconRawBitmap favicon_bitmap2 = favicon_bitmaps[1];
 
   // Favicon bitmaps do not need to be in particular order.
   if (favicon_bitmap1.pixel_size == kLargeSize) {
-    FaviconBitmap tmp_favicon_bitmap = favicon_bitmap1;
+    FaviconRawBitmap tmp_favicon_bitmap = favicon_bitmap1;
     favicon_bitmap1 = favicon_bitmap2;
     favicon_bitmap2 = tmp_favicon_bitmap;
   }
 
   EXPECT_TRUE(BitmapDataEqual('a', favicon_bitmap1.bitmap_data));
   EXPECT_EQ(kSmallSize, favicon_bitmap1.pixel_size);
 
   EXPECT_TRUE(BitmapDataEqual('b', favicon_bitmap2.bitmap_data));
   EXPECT_EQ(kLargeSize, favicon_bitmap2.pixel_size);
 
@@ skipping 867 matching lines @@
 
   history::RedirectList redirects;
   redirects.push_back(url2);
   redirects.push_back(url1);
   backend_->recent_redirects_.Put(url1, redirects);
 
   const GURL icon_url1("http://www.google.com/icon");
   const GURL icon_url2("http://www.google.com/icon2");
 
   // Generate bitmap data for a page with two favicons.
-  std::vector<favicon_base::FaviconBitmapData> two_favicon_bitmap_data;
-  GenerateFaviconBitmapData(icon_url1, GetSizesSmallAndLarge(),
-      icon_url2, GetSizesSmallAndLarge(), &two_favicon_bitmap_data);
+  std::vector<favicon_base::FaviconRawBitmapData> two_favicon_bitmap_data;
+  GenerateFaviconRawBitmapData(icon_url1,
+                               GetSizesSmallAndLarge(),
+                               icon_url2,
+                               GetSizesSmallAndLarge(),
+                               &two_favicon_bitmap_data);
 
   // Generate bitmap data for a page with a single favicon.
-  std::vector<favicon_base::FaviconBitmapData> one_favicon_bitmap_data;
-  GenerateFaviconBitmapData(icon_url1, GetSizesSmallAndLarge(),
-                            &one_favicon_bitmap_data);
+  std::vector<favicon_base::FaviconRawBitmapData> one_favicon_bitmap_data;
+  GenerateFaviconRawBitmapData(
+      icon_url1, GetSizesSmallAndLarge(), &one_favicon_bitmap_data);
 
   // Add two favicons
   backend_->SetFavicons(url1, favicon_base::FAVICON, two_favicon_bitmap_data);
   EXPECT_EQ(2u, NumIconMappingsForPageURL(url1, favicon_base::FAVICON));
   EXPECT_EQ(2u, NumIconMappingsForPageURL(url2, favicon_base::FAVICON));
 
   // Add one touch_icon
   backend_->SetFavicons(
       url1, favicon_base::TOUCH_ICON, one_favicon_bitmap_data);
   EXPECT_EQ(1u, NumIconMappingsForPageURL(url1, favicon_base::TOUCH_ICON));
@@ skipping 34 matching lines @@
   EXPECT_EQ(1u, NumIconMappingsForPageURL(url1, favicon_base::TOUCH_ICON));
   EXPECT_EQ(2u, NumIconMappingsForPageURL(url1, favicon_base::FAVICON));
 }
 
 // Test that there is no churn in icon mappings from calling
 // SetFavicons() twice with the same |favicon_bitmap_data| parameter.
 TEST_F(HistoryBackendTest, SetFaviconMappingsForPageDuplicates) {
   const GURL url("http://www.google.com/");
   const GURL icon_url("http://www.google.com/icon");
 
-  std::vector<favicon_base::FaviconBitmapData> favicon_bitmap_data;
-  GenerateFaviconBitmapData(icon_url, GetSizesSmallAndLarge(),
-                            &favicon_bitmap_data);
+  std::vector<favicon_base::FaviconRawBitmapData> favicon_bitmap_data;
+  GenerateFaviconRawBitmapData(
+      icon_url, GetSizesSmallAndLarge(), &favicon_bitmap_data);
 
   backend_->SetFavicons(url, favicon_base::FAVICON, favicon_bitmap_data);
 
   std::vector<IconMapping> icon_mappings;
   EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingsForPageURL(
       url, favicon_base::FAVICON, &icon_mappings));
   EXPECT_EQ(1u, icon_mappings.size());
   IconMappingID mapping_id = icon_mappings[0].mapping_id;
 
   backend_->SetFavicons(url, favicon_base::FAVICON, favicon_bitmap_data);
 
   icon_mappings.clear();
   EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingsForPageURL(
       url, favicon_base::FAVICON, &icon_mappings));
   EXPECT_EQ(1u, icon_mappings.size());
 
   // The same row in the icon_mapping table should be used for the mapping as
   // before.
   EXPECT_EQ(mapping_id, icon_mappings[0].mapping_id);
 }
 
-// Test that calling SetFavicons() with FaviconBitmapData of different pixel
-// sizes than the initially passed in FaviconBitmapData deletes the no longer
+// Test that calling SetFavicons() with FaviconRawBitmapData of different pixel
+// sizes than the initially passed in FaviconRawBitmapData deletes the no longer
 // used favicon bitmaps.
 TEST_F(HistoryBackendTest, SetFaviconsDeleteBitmaps) {
   const GURL page_url("http://www.google.com/");
   const GURL icon_url("http://www.google.com/icon");
 
-  std::vector<favicon_base::FaviconBitmapData> favicon_bitmap_data;
-  GenerateFaviconBitmapData(icon_url, GetSizesSmallAndLarge(),
-                            &favicon_bitmap_data);
+  std::vector<favicon_base::FaviconRawBitmapData> favicon_bitmap_data;
+  GenerateFaviconRawBitmapData(
+      icon_url, GetSizesSmallAndLarge(), &favicon_bitmap_data);
   backend_->SetFavicons(page_url, favicon_base::FAVICON, favicon_bitmap_data);
 
   // Test initial state.
   std::vector<IconMapping> icon_mappings;
   EXPECT_TRUE(GetSortedIconMappingsForPageURL(page_url, &icon_mappings));
   EXPECT_EQ(1u, icon_mappings.size());
   EXPECT_EQ(icon_url, icon_mappings[0].icon_url);
   EXPECT_EQ(favicon_base::FAVICON, icon_mappings[0].icon_type);
   favicon_base::FaviconID favicon_id = icon_mappings[0].icon_id;
 
-  std::vector<FaviconBitmap> favicon_bitmaps;
-  EXPECT_TRUE(GetSortedFaviconBitmaps(favicon_id, &favicon_bitmaps));
+  std::vector<FaviconRawBitmap> favicon_bitmaps;
+  EXPECT_TRUE(GetSortedFaviconRawBitmaps(favicon_id, &favicon_bitmaps));
   EXPECT_EQ(2u, favicon_bitmaps.size());
-  FaviconBitmapID small_bitmap_id = favicon_bitmaps[0].bitmap_id;
+  FaviconRawBitmapID small_bitmap_id = favicon_bitmaps[0].bitmap_id;
   EXPECT_NE(0, small_bitmap_id);
   EXPECT_TRUE(BitmapDataEqual('a', favicon_bitmaps[0].bitmap_data));
   EXPECT_EQ(kSmallSize, favicon_bitmaps[0].pixel_size);
-  FaviconBitmapID large_bitmap_id = favicon_bitmaps[1].bitmap_id;
+  FaviconRawBitmapID large_bitmap_id = favicon_bitmaps[1].bitmap_id;
   EXPECT_NE(0, large_bitmap_id);
   EXPECT_TRUE(BitmapDataEqual('b', favicon_bitmaps[1].bitmap_data));
   EXPECT_EQ(kLargeSize, favicon_bitmaps[1].pixel_size);
 
   // Call SetFavicons() with bitmap data for only the large bitmap. Check that
   // the small bitmap is in fact deleted.
-  GenerateFaviconBitmapData(icon_url, GetSizesLarge(), &favicon_bitmap_data);
+  GenerateFaviconRawBitmapData(icon_url, GetSizesLarge(), &favicon_bitmap_data);
   backend_->SetFavicons(page_url, favicon_base::FAVICON, favicon_bitmap_data);
 
   scoped_refptr<base::RefCountedMemory> bitmap_data_out;
   gfx::Size pixel_size_out;
-  EXPECT_FALSE(backend_->thumbnail_db_->GetFaviconBitmap(small_bitmap_id,
-      NULL, &bitmap_data_out, &pixel_size_out));
-  EXPECT_TRUE(backend_->thumbnail_db_->GetFaviconBitmap(large_bitmap_id,
-      NULL, &bitmap_data_out, &pixel_size_out));
+  EXPECT_FALSE(backend_->thumbnail_db_->GetFaviconRawBitmap(
+      small_bitmap_id, NULL, &bitmap_data_out, &pixel_size_out));
+  EXPECT_TRUE(backend_->thumbnail_db_->GetFaviconRawBitmap(
+      large_bitmap_id, NULL, &bitmap_data_out, &pixel_size_out));
   EXPECT_TRUE(BitmapDataEqual('a', bitmap_data_out));
   EXPECT_EQ(kLargeSize, pixel_size_out);
 
   icon_mappings.clear();
   EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingsForPageURL(page_url,
       &icon_mappings));
   EXPECT_EQ(1u, icon_mappings.size());
   EXPECT_EQ(favicon_id, icon_mappings[0].icon_id);
 
   // Call SetFavicons() with no bitmap data. Check that the bitmaps and icon
   // mappings are deleted.
   favicon_bitmap_data.clear();
   backend_->SetFavicons(page_url, favicon_base::FAVICON, favicon_bitmap_data);
 
-  EXPECT_FALSE(backend_->thumbnail_db_->GetFaviconBitmap(large_bitmap_id, NULL,
-      NULL, NULL));
+  EXPECT_FALSE(backend_->thumbnail_db_->GetFaviconRawBitmap(
+      large_bitmap_id, NULL, NULL, NULL));
   icon_mappings.clear();
   EXPECT_FALSE(backend_->thumbnail_db_->GetIconMappingsForPageURL(page_url,
       &icon_mappings));
 
   // Notifications should have been broadcast for each call to SetFavicons().
   EXPECT_EQ(3, num_broadcasted_notifications());
 }
 
 // Test updating a single favicon bitmap's data via SetFavicons.
 TEST_F(HistoryBackendTest, SetFaviconsReplaceBitmapData) {
   const GURL page_url("http://www.google.com/");
   const GURL icon_url("http://www.google.com/icon");
 
   std::vector<unsigned char> data_initial;
   data_initial.push_back('a');
 
-  favicon_base::FaviconBitmapData bitmap_data_element;
+  favicon_base::FaviconRawBitmapData bitmap_data_element;
   bitmap_data_element.bitmap_data =
       base::RefCountedBytes::TakeVector(&data_initial);
   bitmap_data_element.pixel_size = kSmallSize;
   bitmap_data_element.icon_url = icon_url;
-  std::vector<favicon_base::FaviconBitmapData> favicon_bitmap_data;
+  std::vector<favicon_base::FaviconRawBitmapData> favicon_bitmap_data;
   favicon_bitmap_data.push_back(bitmap_data_element);
 
   // Add bitmap to the database.
   backend_->SetFavicons(page_url, favicon_base::FAVICON, favicon_bitmap_data);
 
   favicon_base::FaviconID original_favicon_id =
       backend_->thumbnail_db_->GetFaviconIDForFaviconURL(
           icon_url, favicon_base::FAVICON, NULL);
   EXPECT_NE(0, original_favicon_id);
-  FaviconBitmap original_favicon_bitmap;
+  FaviconRawBitmap original_favicon_bitmap;
   EXPECT_TRUE(
-      GetOnlyFaviconBitmap(original_favicon_id, &original_favicon_bitmap));
+      GetOnlyFaviconRawBitmap(original_favicon_id, &original_favicon_bitmap));
   EXPECT_TRUE(BitmapDataEqual('a', original_favicon_bitmap.bitmap_data));
 
   EXPECT_EQ(1, num_broadcasted_notifications());
 
   // Call SetFavicons() with completely identical data.
   std::vector<unsigned char> updated_data;
   updated_data.push_back('a');
   favicon_bitmap_data[0].bitmap_data = new base::RefCountedBytes(updated_data);
   backend_->SetFavicons(page_url, favicon_base::FAVICON, favicon_bitmap_data);
 
   favicon_base::FaviconID updated_favicon_id =
       backend_->thumbnail_db_->GetFaviconIDForFaviconURL(
           icon_url, favicon_base::FAVICON, NULL);
   EXPECT_NE(0, updated_favicon_id);
-  FaviconBitmap updated_favicon_bitmap;
+  FaviconRawBitmap updated_favicon_bitmap;
   EXPECT_TRUE(
-      GetOnlyFaviconBitmap(updated_favicon_id, &updated_favicon_bitmap));
+      GetOnlyFaviconRawBitmap(updated_favicon_id, &updated_favicon_bitmap));
   EXPECT_TRUE(BitmapDataEqual('a', updated_favicon_bitmap.bitmap_data));
 
   // Because the bitmap data is byte equivalent, no notifications should have
   // been broadcasted.
   EXPECT_EQ(1, num_broadcasted_notifications());
 
   // Call SetFavicons() with identical data but a different bitmap.
   updated_data[0] = 'b';
   favicon_bitmap_data[0].bitmap_data = new base::RefCountedBytes(updated_data);
   backend_->SetFavicons(page_url, favicon_base::FAVICON, favicon_bitmap_data);
 
   updated_favicon_id = backend_->thumbnail_db_->GetFaviconIDForFaviconURL(
       icon_url, favicon_base::FAVICON, NULL);
   EXPECT_NE(0, updated_favicon_id);
   EXPECT_TRUE(
-      GetOnlyFaviconBitmap(updated_favicon_id, &updated_favicon_bitmap));
+      GetOnlyFaviconRawBitmap(updated_favicon_id, &updated_favicon_bitmap));
   EXPECT_TRUE(BitmapDataEqual('b', updated_favicon_bitmap.bitmap_data));
 
-  // There should be no churn in FaviconIDs or FaviconBitmapIds even though
+  // There should be no churn in FaviconIDs or FaviconRawBitmapIds even though
   // the bitmap data changed.
   EXPECT_EQ(original_favicon_bitmap.icon_id, updated_favicon_bitmap.icon_id);
   EXPECT_EQ(original_favicon_bitmap.bitmap_id,
             updated_favicon_bitmap.bitmap_id);
 
   // A notification should have been broadcasted as the favicon bitmap data has
   // changed.
   EXPECT_EQ(2, num_broadcasted_notifications());
 }
 
 // Test that if two pages share the same FaviconID, changing the favicon for
 // one page does not affect the other.
 TEST_F(HistoryBackendTest, SetFaviconsSameFaviconURLForTwoPages) {
   GURL icon_url("http://www.google.com/favicon.ico");
   GURL icon_url_new("http://www.google.com/favicon2.ico");
   GURL page_url1("http://www.google.com");
   GURL page_url2("http://www.google.ca");
 
-  std::vector<favicon_base::FaviconBitmapData> favicon_bitmap_data;
-  GenerateFaviconBitmapData(icon_url, GetSizesSmallAndLarge(),
-                            &favicon_bitmap_data);
+  std::vector<favicon_base::FaviconRawBitmapData> favicon_bitmap_data;
+  GenerateFaviconRawBitmapData(
+      icon_url, GetSizesSmallAndLarge(), &favicon_bitmap_data);
 
   backend_->SetFavicons(page_url1, favicon_base::FAVICON, favicon_bitmap_data);
 
   std::vector<GURL> icon_urls;
   icon_urls.push_back(icon_url);
 
-  std::vector<favicon_base::FaviconBitmapResult> bitmap_results;
+  std::vector<favicon_base::FaviconRawBitmapResult> bitmap_results;
   backend_->UpdateFaviconMappingsAndFetch(page_url2,
                                           icon_urls,
                                           favicon_base::FAVICON,
                                           kSmallSize.width(),
                                           GetScaleFactors1x2x(),
                                           &bitmap_results);
 
   // Check that the same FaviconID is mapped to both page URLs.
   std::vector<IconMapping> icon_mappings;
   EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingsForPageURL(
       page_url1, &icon_mappings));
   EXPECT_EQ(1u, icon_mappings.size());
   favicon_base::FaviconID favicon_id = icon_mappings[0].icon_id;
   EXPECT_NE(0, favicon_id);
 
   icon_mappings.clear();
   EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingsForPageURL(
       page_url2, &icon_mappings));
   EXPECT_EQ(1u, icon_mappings.size());
   EXPECT_EQ(favicon_id, icon_mappings[0].icon_id);
 
   // Change the icon URL that |page_url1| is mapped to.
-  GenerateFaviconBitmapData(icon_url_new, GetSizesSmall(),
-                            &favicon_bitmap_data);
+  GenerateFaviconRawBitmapData(
+      icon_url_new, GetSizesSmall(), &favicon_bitmap_data);
   backend_->SetFavicons(page_url1, favicon_base::FAVICON, favicon_bitmap_data);
 
   // |page_url1| should map to a new FaviconID and have valid bitmap data.
   icon_mappings.clear();
   EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingsForPageURL(
       page_url1, &icon_mappings));
   EXPECT_EQ(1u, icon_mappings.size());
   EXPECT_EQ(icon_url_new, icon_mappings[0].icon_url);
   EXPECT_NE(favicon_id, icon_mappings[0].icon_id);
 
-  std::vector<FaviconBitmap> favicon_bitmaps;
-  EXPECT_TRUE(backend_->thumbnail_db_->GetFaviconBitmaps(
+  std::vector<FaviconRawBitmap> favicon_bitmaps;
+  EXPECT_TRUE(backend_->thumbnail_db_->GetFaviconRawBitmaps(
       icon_mappings[0].icon_id, &favicon_bitmaps));
   EXPECT_EQ(1u, favicon_bitmaps.size());
 
   // |page_url2| should still map to the same FaviconID and have valid bitmap
   // data.
   icon_mappings.clear();
   EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingsForPageURL(
       page_url2, &icon_mappings));
   EXPECT_EQ(1u, icon_mappings.size());
   EXPECT_EQ(favicon_id, icon_mappings[0].icon_id);
 
   favicon_bitmaps.clear();
-  EXPECT_TRUE(backend_->thumbnail_db_->GetFaviconBitmaps(favicon_id,
-                                                         &favicon_bitmaps));
+  EXPECT_TRUE(backend_->thumbnail_db_->GetFaviconRawBitmaps(favicon_id,
+                                                            &favicon_bitmaps));
   EXPECT_EQ(2u, favicon_bitmaps.size());
 
   // A notification should have been broadcast for each call to SetFavicons()
   // and each call to UpdateFaviconMappingsAndFetch().
   EXPECT_EQ(3, num_broadcasted_notifications());
 }
 
 // Test that no notifications are broadcast as a result of calling
 // UpdateFaviconMappingsAndFetch() for an icon URL which is already
 // mapped to the passed in page URL.
 TEST_F(HistoryBackendTest, UpdateFaviconMappingsAndFetchNoChange) {
   GURL page_url("http://www.google.com");
   GURL icon_url("http://www.google.com/favicon.ico");
-  std::vector<favicon_base::FaviconBitmapData> favicon_bitmap_data;
-  GenerateFaviconBitmapData(icon_url, GetSizesSmall(), &favicon_bitmap_data);
+  std::vector<favicon_base::FaviconRawBitmapData> favicon_bitmap_data;
+  GenerateFaviconRawBitmapData(icon_url, GetSizesSmall(), &favicon_bitmap_data);
 
   backend_->SetFavicons(page_url, favicon_base::FAVICON, favicon_bitmap_data);
 
   favicon_base::FaviconID icon_id =
       backend_->thumbnail_db_->GetFaviconIDForFaviconURL(
           icon_url, favicon_base::FAVICON, NULL);
   EXPECT_NE(0, icon_id);
   EXPECT_EQ(1, num_broadcasted_notifications());
 
   std::vector<GURL> icon_urls;
   icon_urls.push_back(icon_url);
 
-  std::vector<favicon_base::FaviconBitmapResult> bitmap_results;
+  std::vector<favicon_base::FaviconRawBitmapResult> bitmap_results;
   backend_->UpdateFaviconMappingsAndFetch(page_url,
                                           icon_urls,
                                           favicon_base::FAVICON,
                                           kSmallSize.width(),
                                           GetScaleFactors1x2x(),
                                           &bitmap_results);
 
   EXPECT_EQ(icon_id,
             backend_->thumbnail_db_->GetFaviconIDForFaviconURL(
                 icon_url, favicon_base::FAVICON, NULL));
@@ skipping 18 matching lines @@
       page_url, icon_url, favicon_base::FAVICON, bitmap_data, kSmallSize);
 
   // |page_url| should now be mapped to |icon_url| and the favicon bitmap should
   // not be expired.
   std::vector<IconMapping> icon_mappings;
   EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingsForPageURL(page_url,
       &icon_mappings));
   EXPECT_EQ(1u, icon_mappings.size());
   EXPECT_EQ(icon_url, icon_mappings[0].icon_url);
 
-  FaviconBitmap favicon_bitmap;
-  EXPECT_TRUE(GetOnlyFaviconBitmap(icon_mappings[0].icon_id, &favicon_bitmap));
+  FaviconRawBitmap favicon_bitmap;
+  EXPECT_TRUE(
+      GetOnlyFaviconRawBitmap(icon_mappings[0].icon_id, &favicon_bitmap));
   EXPECT_NE(base::Time(), favicon_bitmap.last_updated);
   EXPECT_TRUE(BitmapDataEqual('a', favicon_bitmap.bitmap_data));
   EXPECT_EQ(kSmallSize, favicon_bitmap.pixel_size);
 
   data[0] = 'b';
   bitmap_data = new base::RefCountedBytes(data);
   backend_->MergeFavicon(
       page_url, icon_url, favicon_base::FAVICON, bitmap_data, kSmallSize);
 
   // |page_url| should still have a single favicon bitmap. The bitmap data
   // should be updated.
   icon_mappings.clear();
   EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingsForPageURL(page_url,
       &icon_mappings));
   EXPECT_EQ(1u, icon_mappings.size());
   EXPECT_EQ(icon_url, icon_mappings[0].icon_url);
 
-  EXPECT_TRUE(GetOnlyFaviconBitmap(icon_mappings[0].icon_id, &favicon_bitmap));
+  EXPECT_TRUE(
+      GetOnlyFaviconRawBitmap(icon_mappings[0].icon_id, &favicon_bitmap));
   EXPECT_NE(base::Time(), favicon_bitmap.last_updated);
   EXPECT_TRUE(BitmapDataEqual('b', favicon_bitmap.bitmap_data));
   EXPECT_EQ(kSmallSize, favicon_bitmap.pixel_size);
 }
 
 // Test calling MergeFavicon() when |page_url| is known to the database.
 TEST_F(HistoryBackendTest, MergeFaviconPageURLInDB) {
   GURL page_url("http://www.google.com");
   GURL icon_url1("http:/www.google.com/favicon.ico");
   GURL icon_url2("http://www.google.com/favicon2.ico");
 
-  std::vector<favicon_base::FaviconBitmapData> favicon_bitmap_data;
-  GenerateFaviconBitmapData(icon_url1, GetSizesSmall(),
-                            &favicon_bitmap_data);
+  std::vector<favicon_base::FaviconRawBitmapData> favicon_bitmap_data;
+  GenerateFaviconRawBitmapData(
+      icon_url1, GetSizesSmall(), &favicon_bitmap_data);
 
   backend_->SetFavicons(page_url, favicon_base::FAVICON, favicon_bitmap_data);
 
   // Test initial state.
   std::vector<IconMapping> icon_mappings;
   EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingsForPageURL(page_url,
       &icon_mappings));
   EXPECT_EQ(1u, icon_mappings.size());
   EXPECT_EQ(icon_url1, icon_mappings[0].icon_url);
 
-  FaviconBitmap favicon_bitmap;
-  EXPECT_TRUE(GetOnlyFaviconBitmap(icon_mappings[0].icon_id, &favicon_bitmap));
+  FaviconRawBitmap favicon_bitmap;
+  EXPECT_TRUE(
+      GetOnlyFaviconRawBitmap(icon_mappings[0].icon_id, &favicon_bitmap));
   EXPECT_NE(base::Time(), favicon_bitmap.last_updated);
   EXPECT_TRUE(BitmapDataEqual('a', favicon_bitmap.bitmap_data));
   EXPECT_EQ(kSmallSize, favicon_bitmap.pixel_size);
 
   EXPECT_EQ(1, num_broadcasted_notifications());
 
   // 1) Merge identical favicon bitmap.
   std::vector<unsigned char> data;
   data.push_back('a');
   scoped_refptr<base::RefCountedBytes> bitmap_data(
       new base::RefCountedBytes(data));
   backend_->MergeFavicon(
       page_url, icon_url1, favicon_base::FAVICON, bitmap_data, kSmallSize);
 
   // All the data should stay the same and no notifications should have been
   // sent.
   icon_mappings.clear();
   EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingsForPageURL(page_url,
       &icon_mappings));
   EXPECT_EQ(1u, icon_mappings.size());
   EXPECT_EQ(icon_url1, icon_mappings[0].icon_url);
 
-  EXPECT_TRUE(GetOnlyFaviconBitmap(icon_mappings[0].icon_id, &favicon_bitmap));
+  EXPECT_TRUE(
+      GetOnlyFaviconRawBitmap(icon_mappings[0].icon_id, &favicon_bitmap));
   EXPECT_NE(base::Time(), favicon_bitmap.last_updated);
   EXPECT_TRUE(BitmapDataEqual('a', favicon_bitmap.bitmap_data));
   EXPECT_EQ(kSmallSize, favicon_bitmap.pixel_size);
 
   EXPECT_EQ(1, num_broadcasted_notifications());
 
   // 2) Merge favicon bitmap of the same size.
   data[0] = 'b';
   bitmap_data = new base::RefCountedBytes(data);
   backend_->MergeFavicon(
       page_url, icon_url1, favicon_base::FAVICON, bitmap_data, kSmallSize);
 
   // The small favicon bitmap at |icon_url1| should be overwritten.
   icon_mappings.clear();
   EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingsForPageURL(page_url,
       &icon_mappings));
   EXPECT_EQ(1u, icon_mappings.size());
   EXPECT_EQ(icon_url1, icon_mappings[0].icon_url);
 
-  EXPECT_TRUE(GetOnlyFaviconBitmap(icon_mappings[0].icon_id, &favicon_bitmap));
+  EXPECT_TRUE(
+      GetOnlyFaviconRawBitmap(icon_mappings[0].icon_id, &favicon_bitmap));
   EXPECT_NE(base::Time(), favicon_bitmap.last_updated);
   EXPECT_TRUE(BitmapDataEqual('b', favicon_bitmap.bitmap_data));
   EXPECT_EQ(kSmallSize, favicon_bitmap.pixel_size);
 
   // 3) Merge favicon for the same icon URL, but a pixel size for which there is
   // no favicon bitmap.
   data[0] = 'c';
   bitmap_data = new base::RefCountedBytes(data);
   backend_->MergeFavicon(
       page_url, icon_url1, favicon_base::FAVICON, bitmap_data, kTinySize);
 
   // A new favicon bitmap should be created and the preexisting favicon bitmap
   // ('b') should be expired.
   icon_mappings.clear();
   EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingsForPageURL(page_url,
       &icon_mappings));
   EXPECT_EQ(1u, icon_mappings.size());
   EXPECT_EQ(icon_url1, icon_mappings[0].icon_url);
 
-  std::vector<FaviconBitmap> favicon_bitmaps;
-  EXPECT_TRUE(GetSortedFaviconBitmaps(icon_mappings[0].icon_id,
-                                      &favicon_bitmaps));
+  std::vector<FaviconRawBitmap> favicon_bitmaps;
+  EXPECT_TRUE(
+      GetSortedFaviconRawBitmaps(icon_mappings[0].icon_id, &favicon_bitmaps));
   EXPECT_NE(base::Time(), favicon_bitmaps[0].last_updated);
   EXPECT_TRUE(BitmapDataEqual('c', favicon_bitmaps[0].bitmap_data));
   EXPECT_EQ(kTinySize, favicon_bitmaps[0].pixel_size);
   EXPECT_EQ(base::Time(), favicon_bitmaps[1].last_updated);
   EXPECT_TRUE(BitmapDataEqual('b', favicon_bitmaps[1].bitmap_data));
   EXPECT_EQ(kSmallSize, favicon_bitmaps[1].pixel_size);
 
   // 4) Merge favicon for an icon URL different from the icon URLs already
   // mapped to page URL.
   data[0] = 'd';
   bitmap_data = new base::RefCountedBytes(data);
   backend_->MergeFavicon(
       page_url, icon_url2, favicon_base::FAVICON, bitmap_data, kSmallSize);
 
   // The existing favicon bitmaps should be copied over to the newly created
   // favicon at |icon_url2|. |page_url| should solely be mapped to |icon_url2|.
   icon_mappings.clear();
   EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingsForPageURL(page_url,
       &icon_mappings));
   EXPECT_EQ(1u, icon_mappings.size());
   EXPECT_EQ(icon_url2, icon_mappings[0].icon_url);
 
   favicon_bitmaps.clear();
-  EXPECT_TRUE(GetSortedFaviconBitmaps(icon_mappings[0].icon_id,
-                                      &favicon_bitmaps));
+  EXPECT_TRUE(
+      GetSortedFaviconRawBitmaps(icon_mappings[0].icon_id, &favicon_bitmaps));
   EXPECT_EQ(base::Time(), favicon_bitmaps[0].last_updated);
   EXPECT_TRUE(BitmapDataEqual('c', favicon_bitmaps[0].bitmap_data));
   EXPECT_EQ(kTinySize, favicon_bitmaps[0].pixel_size);
   // The favicon being merged should take precedence over the preexisting
   // favicon bitmaps.
   EXPECT_NE(base::Time(), favicon_bitmaps[1].last_updated);
   EXPECT_TRUE(BitmapDataEqual('d', favicon_bitmaps[1].bitmap_data));
   EXPECT_EQ(kSmallSize, favicon_bitmaps[1].pixel_size);
 
   // A notification should have been broadcast for each call to SetFavicons()
   // and MergeFavicon().
   EXPECT_EQ(4, num_broadcasted_notifications());
 }
 
 // Test calling MergeFavicon() when |icon_url| is known to the database but not
 // mapped to |page_url|.
 TEST_F(HistoryBackendTest, MergeFaviconIconURLMappedToDifferentPageURL) {
   GURL page_url1("http://www.google.com");
   GURL page_url2("http://news.google.com");
   GURL page_url3("http://maps.google.com");
   GURL icon_url("http:/www.google.com/favicon.ico");
 
-  std::vector<favicon_base::FaviconBitmapData> favicon_bitmap_data;
-  GenerateFaviconBitmapData(icon_url, GetSizesSmall(),
-                            &favicon_bitmap_data);
+  std::vector<favicon_base::FaviconRawBitmapData> favicon_bitmap_data;
+  GenerateFaviconRawBitmapData(icon_url, GetSizesSmall(), &favicon_bitmap_data);
 
   backend_->SetFavicons(page_url1, favicon_base::FAVICON, favicon_bitmap_data);
 
   // Test initial state.
   std::vector<IconMapping> icon_mappings;
   EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingsForPageURL(page_url1,
       &icon_mappings));
   EXPECT_EQ(1u, icon_mappings.size());
   EXPECT_EQ(icon_url, icon_mappings[0].icon_url);
 
-  FaviconBitmap favicon_bitmap;
-  EXPECT_TRUE(GetOnlyFaviconBitmap(icon_mappings[0].icon_id, &favicon_bitmap));
+  FaviconRawBitmap favicon_bitmap;
+  EXPECT_TRUE(
+      GetOnlyFaviconRawBitmap(icon_mappings[0].icon_id, &favicon_bitmap));
   EXPECT_NE(base::Time(), favicon_bitmap.last_updated);
   EXPECT_TRUE(BitmapDataEqual('a', favicon_bitmap.bitmap_data));
   EXPECT_EQ(kSmallSize, favicon_bitmap.pixel_size);
 
   // 1) Merge in an identical favicon bitmap data but for a different page URL.
   std::vector<unsigned char> data;
   data.push_back('a');
   scoped_refptr<base::RefCountedBytes> bitmap_data(
       new base::RefCountedBytes(data));
 
   backend_->MergeFavicon(
       page_url2, icon_url, favicon_base::FAVICON, bitmap_data, kSmallSize);
 
   favicon_base::FaviconID favicon_id =
       backend_->thumbnail_db_->GetFaviconIDForFaviconURL(
           icon_url, favicon_base::FAVICON, NULL);
   EXPECT_NE(0, favicon_id);
 
-  EXPECT_TRUE(GetOnlyFaviconBitmap(favicon_id, &favicon_bitmap));
+  EXPECT_TRUE(GetOnlyFaviconRawBitmap(favicon_id, &favicon_bitmap));
   EXPECT_NE(base::Time(), favicon_bitmap.last_updated);
   EXPECT_TRUE(BitmapDataEqual('a', favicon_bitmap.bitmap_data));
   EXPECT_EQ(kSmallSize, favicon_bitmap.pixel_size);
 
   // 2) Merging a favicon bitmap with different bitmap data for the same icon
   // URL should overwrite the small favicon bitmap at |icon_url|.
   bitmap_data->data()[0] = 'b';
   backend_->MergeFavicon(
       page_url3, icon_url, favicon_base::FAVICON, bitmap_data, kSmallSize);
 
   favicon_id = backend_->thumbnail_db_->GetFaviconIDForFaviconURL(
       icon_url, favicon_base::FAVICON, NULL);
   EXPECT_NE(0, favicon_id);
 
-  EXPECT_TRUE(GetOnlyFaviconBitmap(favicon_id, &favicon_bitmap));
+  EXPECT_TRUE(GetOnlyFaviconRawBitmap(favicon_id, &favicon_bitmap));
   EXPECT_NE(base::Time(), favicon_bitmap.last_updated);
   EXPECT_TRUE(BitmapDataEqual('b', favicon_bitmap.bitmap_data));
   EXPECT_EQ(kSmallSize, favicon_bitmap.pixel_size);
 
   // |icon_url| should be mapped to all three page URLs.
   icon_mappings.clear();
   EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingsForPageURL(page_url1,
       &icon_mappings));
   EXPECT_EQ(1u, icon_mappings.size());
   EXPECT_EQ(favicon_id, icon_mappings[0].icon_id);
 
   icon_mappings.clear();
   EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingsForPageURL(page_url2,
       &icon_mappings));
   EXPECT_EQ(1u, icon_mappings.size());
   EXPECT_EQ(favicon_id, icon_mappings[0].icon_id);
 
   icon_mappings.clear();
   EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingsForPageURL(page_url3,
       &icon_mappings));
   EXPECT_EQ(1u, icon_mappings.size());
   EXPECT_EQ(favicon_id, icon_mappings[0].icon_id);
 
   // A notification should have been broadcast for each call to SetFavicons()
   // and MergeFavicon().
   EXPECT_EQ(3, num_broadcasted_notifications());
 }
 
 // Test that MergeFavicon() does not add more than
-// |kMaxFaviconBitmapsPerIconURL| to a favicon.
-TEST_F(HistoryBackendTest, MergeFaviconMaxFaviconBitmapsPerIconURL) {
+// |kMaxFaviconRawBitmapsPerIconURL| to a favicon.
+TEST_F(HistoryBackendTest, MergeFaviconMaxFaviconRawBitmapsPerIconURL) {
   GURL page_url("http://www.google.com");
   std::string icon_url_string("http://www.google.com/favicon.ico");
   size_t replace_index = icon_url_string.size() - 1;
 
   std::vector<unsigned char> data;
   data.push_back('a');
   scoped_refptr<base::RefCountedMemory> bitmap_data =
       base::RefCountedBytes::TakeVector(&data);
 
   int pixel_size = 1;
-  for (size_t i = 0; i < kMaxFaviconBitmapsPerIconURL + 1; ++i) {
+  for (size_t i = 0; i < kMaxFaviconRawBitmapsPerIconURL + 1; ++i) {
     icon_url_string[replace_index] = '0' + i;
     GURL icon_url(icon_url_string);
 
     backend_->MergeFavicon(page_url,
                            icon_url,
                            favicon_base::FAVICON,
                            bitmap_data,
                            gfx::Size(pixel_size, pixel_size));
     ++pixel_size;
   }
 
   // There should be a single favicon mapped to |page_url| with exactly
-  // kMaxFaviconBitmapsPerIconURL favicon bitmaps.
+  // kMaxFaviconRawBitmapsPerIconURL favicon bitmaps.
   std::vector<IconMapping> icon_mappings;
   EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingsForPageURL(page_url,
       &icon_mappings));
   EXPECT_EQ(1u, icon_mappings.size());
-  std::vector<FaviconBitmap> favicon_bitmaps;
-  EXPECT_TRUE(backend_->thumbnail_db_->GetFaviconBitmaps(
+  std::vector<FaviconRawBitmap> favicon_bitmaps;
+  EXPECT_TRUE(backend_->thumbnail_db_->GetFaviconRawBitmaps(
       icon_mappings[0].icon_id, &favicon_bitmaps));
-  EXPECT_EQ(kMaxFaviconBitmapsPerIconURL, favicon_bitmaps.size());
+  EXPECT_EQ(kMaxFaviconRawBitmapsPerIconURL, favicon_bitmaps.size());
 }
 
 // Tests that the favicon set by MergeFavicon() shows up in the result of
 // GetFaviconsForURL().
 TEST_F(HistoryBackendTest, MergeFaviconShowsUpInGetFaviconsForURLResult) {
   GURL page_url("http://www.google.com");
   GURL icon_url("http://www.google.com/favicon.ico");
   GURL merged_icon_url("http://wwww.google.com/favicon2.ico");
 
-  std::vector<favicon_base::FaviconBitmapData> favicon_bitmap_data;
-  GenerateFaviconBitmapData(icon_url, GetSizesSmallAndLarge(),
-                            &favicon_bitmap_data);
+  std::vector<favicon_base::FaviconRawBitmapData> favicon_bitmap_data;
+  GenerateFaviconRawBitmapData(
+      icon_url, GetSizesSmallAndLarge(), &favicon_bitmap_data);
 
   // Set some preexisting favicons for |page_url|.
   backend_->SetFavicons(page_url, favicon_base::FAVICON, favicon_bitmap_data);
 
   // Merge small favicon.
   std::vector<unsigned char> data;
   data.push_back('c');
   scoped_refptr<base::RefCountedBytes> bitmap_data(
       new base::RefCountedBytes(data));
   backend_->MergeFavicon(page_url,
                          merged_icon_url,
                          favicon_base::FAVICON,
                          bitmap_data,
                          kSmallSize);
 
   // Request favicon bitmaps for both 1x and 2x to simulate request done by
   // BookmarkModel::GetFavicon().
-  std::vector<favicon_base::FaviconBitmapResult> bitmap_results;
+  std::vector<favicon_base::FaviconRawBitmapResult> bitmap_results;
   backend_->GetFaviconsForURL(page_url,
                               favicon_base::FAVICON,
                               kSmallSize.width(),
                               GetScaleFactors1x2x(),
                               &bitmap_results);
 
   EXPECT_EQ(2u, bitmap_results.size());
-  const favicon_base::FaviconBitmapResult& first_result = bitmap_results[0];
-  const favicon_base::FaviconBitmapResult& result =
+  const favicon_base::FaviconRawBitmapResult& first_result = bitmap_results[0];
+  const favicon_base::FaviconRawBitmapResult& result =
       (first_result.pixel_size == kSmallSize) ? first_result
                                               : bitmap_results[1];
   EXPECT_TRUE(BitmapDataEqual('c', result.bitmap_data));
 }
 
 // Tests GetFaviconsForURL with icon_types priority,
 TEST_F(HistoryBackendTest, TestGetFaviconsForURLWithIconTypesPriority) {
   GURL page_url("http://www.google.com");
   GURL icon_url("http://www.google.com/favicon.ico");
   GURL touch_icon_url("http://wwww.google.com/touch_icon.ico");
 
-  std::vector<favicon_base::FaviconBitmapData> favicon_bitmap_data;
+  std::vector<favicon_base::FaviconRawBitmapData> favicon_bitmap_data;
   std::vector<gfx::Size> favicon_size;
   favicon_size.push_back(gfx::Size(16, 16));
   favicon_size.push_back(gfx::Size(32, 32));
-  GenerateFaviconBitmapData(icon_url, favicon_size, &favicon_bitmap_data);
+  GenerateFaviconRawBitmapData(icon_url, favicon_size, &favicon_bitmap_data);
   ASSERT_EQ(2u, favicon_bitmap_data.size());
 
-  std::vector<favicon_base::FaviconBitmapData> touch_icon_bitmap_data;
+  std::vector<favicon_base::FaviconRawBitmapData> touch_icon_bitmap_data;
   std::vector<gfx::Size> touch_icon_size;
   touch_icon_size.push_back(gfx::Size(64, 64));
-  GenerateFaviconBitmapData(icon_url, touch_icon_size, &touch_icon_bitmap_data);
+  GenerateFaviconRawBitmapData(
+      icon_url, touch_icon_size, &touch_icon_bitmap_data);
   ASSERT_EQ(1u, touch_icon_bitmap_data.size());
 
   // Set some preexisting favicons for |page_url|.
   backend_->SetFavicons(page_url, favicon_base::FAVICON, favicon_bitmap_data);
   backend_->SetFavicons(
       page_url, favicon_base::TOUCH_ICON, touch_icon_bitmap_data);
 
-  favicon_base::FaviconBitmapResult result;
+  favicon_base::FaviconRawBitmapResult result;
   std::vector<int> icon_types;
   icon_types.push_back(favicon_base::FAVICON);
   icon_types.push_back(favicon_base::TOUCH_ICON);
 
   backend_->GetLargestFaviconForURL(page_url, icon_types, 16, &result);
 
   // Verify the result icon is 32x32 favicon.
   EXPECT_EQ(gfx::Size(32, 32), result.pixel_size);
   EXPECT_EQ(favicon_base::FAVICON, result.icon_type);
 
   // Change Minimal size to 32x32 and verify the 64x64 touch icon returned.
   backend_->GetLargestFaviconForURL(page_url, icon_types, 32, &result);
   EXPECT_EQ(gfx::Size(64, 64), result.pixel_size);
   EXPECT_EQ(favicon_base::TOUCH_ICON, result.icon_type);
 }
 
 // Test the the first types of icon is returned if its size equal to the
 // second types icon.
 TEST_F(HistoryBackendTest, TestGetFaviconsForURLReturnFavicon) {
   GURL page_url("http://www.google.com");
   GURL icon_url("http://www.google.com/favicon.ico");
   GURL touch_icon_url("http://wwww.google.com/touch_icon.ico");
 
-  std::vector<favicon_base::FaviconBitmapData> favicon_bitmap_data;
+  std::vector<favicon_base::FaviconRawBitmapData> favicon_bitmap_data;
   std::vector<gfx::Size> favicon_size;
   favicon_size.push_back(gfx::Size(16, 16));
   favicon_size.push_back(gfx::Size(32, 32));
-  GenerateFaviconBitmapData(icon_url, favicon_size, &favicon_bitmap_data);
+  GenerateFaviconRawBitmapData(icon_url, favicon_size, &favicon_bitmap_data);
   ASSERT_EQ(2u, favicon_bitmap_data.size());
 
-  std::vector<favicon_base::FaviconBitmapData> touch_icon_bitmap_data;
+  std::vector<favicon_base::FaviconRawBitmapData> touch_icon_bitmap_data;
   std::vector<gfx::Size> touch_icon_size;
   touch_icon_size.push_back(gfx::Size(32, 32));
-  GenerateFaviconBitmapData(icon_url, touch_icon_size, &touch_icon_bitmap_data);
+  GenerateFaviconRawBitmapData(
+      icon_url, touch_icon_size, &touch_icon_bitmap_data);
   ASSERT_EQ(1u, touch_icon_bitmap_data.size());
 
   // Set some preexisting favicons for |page_url|.
   backend_->SetFavicons(page_url, favicon_base::FAVICON, favicon_bitmap_data);
   backend_->SetFavicons(
       page_url, favicon_base::TOUCH_ICON, touch_icon_bitmap_data);
 
-  favicon_base::FaviconBitmapResult result;
+  favicon_base::FaviconRawBitmapResult result;
   std::vector<int> icon_types;
   icon_types.push_back(favicon_base::FAVICON);
   icon_types.push_back(favicon_base::TOUCH_ICON);
 
   backend_->GetLargestFaviconForURL(page_url, icon_types, 16, &result);
 
   // Verify the result icon is 32x32 favicon.
   EXPECT_EQ(gfx::Size(32, 32), result.pixel_size);
   EXPECT_EQ(favicon_base::FAVICON, result.icon_type);
 
   // Change minimal size to 32x32 and verify the 32x32 favicon returned.
-  favicon_base::FaviconBitmapResult result1;
+  favicon_base::FaviconRawBitmapResult result1;
   backend_->GetLargestFaviconForURL(page_url, icon_types, 32, &result1);
   EXPECT_EQ(gfx::Size(32, 32), result1.pixel_size);
   EXPECT_EQ(favicon_base::FAVICON, result1.icon_type);
 }
 
 // Test the favicon is returned if its size is smaller than minimal size,
 // because it is only one available.
 TEST_F(HistoryBackendTest, TestGetFaviconsForURLReturnFaviconEvenItSmaller) {
   GURL page_url("http://www.google.com");
   GURL icon_url("http://www.google.com/favicon.ico");
 
-  std::vector<favicon_base::FaviconBitmapData> favicon_bitmap_data;
+  std::vector<favicon_base::FaviconRawBitmapData> favicon_bitmap_data;
   std::vector<gfx::Size> favicon_size;
   favicon_size.push_back(gfx::Size(16, 16));
-  GenerateFaviconBitmapData(icon_url, favicon_size, &favicon_bitmap_data);
+  GenerateFaviconRawBitmapData(icon_url, favicon_size, &favicon_bitmap_data);
   ASSERT_EQ(1u, favicon_bitmap_data.size());
 
   // Set preexisting favicons for |page_url|.
   backend_->SetFavicons(page_url, favicon_base::FAVICON, favicon_bitmap_data);
 
-  favicon_base::FaviconBitmapResult result;
+  favicon_base::FaviconRawBitmapResult result;
   std::vector<int> icon_types;
   icon_types.push_back(favicon_base::FAVICON);
   icon_types.push_back(favicon_base::TOUCH_ICON);
 
   backend_->GetLargestFaviconForURL(page_url, icon_types, 32, &result);
 
   // Verify 16x16 icon is returned, even it small than minimal_size.
   EXPECT_EQ(gfx::Size(16, 16), result.pixel_size);
   EXPECT_EQ(favicon_base::FAVICON, result.icon_type);
 }
 
 // Test UpdateFaviconMapingsAndFetch() when multiple icon types are passed in.
 TEST_F(HistoryBackendTest, UpdateFaviconMappingsAndFetchMultipleIconTypes) {
   GURL page_url1("http://www.google.com");
   GURL page_url2("http://news.google.com");
   GURL page_url3("http://mail.google.com");
   GURL icon_urla("http://www.google.com/favicon1.ico");
   GURL icon_urlb("http://www.google.com/favicon2.ico");
   GURL icon_urlc("http://www.google.com/favicon3.ico");
 
   // |page_url1| is mapped to |icon_urla| which if of type TOUCH_ICON.
-  std::vector<favicon_base::FaviconBitmapData> favicon_bitmap_data;
-  GenerateFaviconBitmapData(icon_urla, GetSizesSmall(), &favicon_bitmap_data);
+  std::vector<favicon_base::FaviconRawBitmapData> favicon_bitmap_data;
+  GenerateFaviconRawBitmapData(
+      icon_urla, GetSizesSmall(), &favicon_bitmap_data);
   backend_->SetFavicons(
       page_url1, favicon_base::TOUCH_ICON, favicon_bitmap_data);
 
   // |page_url2| is mapped to |icon_urlb| and |icon_urlc| which are of type
   // TOUCH_PRECOMPOSED_ICON.
-  GenerateFaviconBitmapData(icon_urlb, GetSizesSmall(), icon_urlc,
-                            GetSizesSmall(), &favicon_bitmap_data);
+  GenerateFaviconRawBitmapData(icon_urlb,
+                               GetSizesSmall(),
+                               icon_urlc,
+                               GetSizesSmall(),
+                               &favicon_bitmap_data);
   backend_->SetFavicons(
       page_url2, favicon_base::TOUCH_PRECOMPOSED_ICON, favicon_bitmap_data);
 
   std::vector<GURL> icon_urls;
   icon_urls.push_back(icon_urla);
   icon_urls.push_back(icon_urlb);
   icon_urls.push_back(icon_urlc);
 
-  std::vector<favicon_base::FaviconBitmapResult> bitmap_results;
+  std::vector<favicon_base::FaviconRawBitmapResult> bitmap_results;
   backend_->UpdateFaviconMappingsAndFetch(
       page_url3,
       icon_urls,
       (favicon_base::TOUCH_ICON | favicon_base::TOUCH_PRECOMPOSED_ICON),
       kSmallSize.width(),
       GetScaleFactors1x2x(),
       &bitmap_results);
 
   // |page_url1| and |page_url2| should still be mapped to the same icon URLs.
   std::vector<IconMapping> icon_mappings;
@@ skipping 20 matching lines @@
   EXPECT_EQ(favicon_base::TOUCH_PRECOMPOSED_ICON, icon_mappings[0].icon_type);
   EXPECT_EQ(icon_urlc, icon_mappings[1].icon_url);
   EXPECT_EQ(favicon_base::TOUCH_PRECOMPOSED_ICON, icon_mappings[1].icon_type);
 }
 
 // Test the results of GetFaviconsFromDB() when there are no found
 // favicons.
 TEST_F(HistoryBackendTest, GetFaviconsFromDBEmpty) {
   const GURL page_url("http://www.google.com/");
 
-  std::vector<favicon_base::FaviconBitmapResult> bitmap_results;
+  std::vector<favicon_base::FaviconRawBitmapResult> bitmap_results;
   EXPECT_FALSE(backend_->GetFaviconsFromDB(page_url,
                                            favicon_base::FAVICON,
                                            kSmallSize.width(),
                                            GetScaleFactors1x2x(),
                                            &bitmap_results));
   EXPECT_TRUE(bitmap_results.empty());
 }
 
 // Test the results of GetFaviconsFromDB() when there are matching favicons
 // but there are no associated favicon bitmaps.
-TEST_F(HistoryBackendTest, GetFaviconsFromDBNoFaviconBitmaps) {
+TEST_F(HistoryBackendTest, GetFaviconsFromDBNoFaviconRawBitmaps) {
   const GURL page_url("http://www.google.com/");
   const GURL icon_url("http://www.google.com/icon1");
 
   favicon_base::FaviconID icon_id =
       backend_->thumbnail_db_->AddFavicon(icon_url, favicon_base::FAVICON);
   EXPECT_NE(0, icon_id);
   EXPECT_NE(0, backend_->thumbnail_db_->AddIconMapping(page_url, icon_id));
 
-  std::vector<favicon_base::FaviconBitmapResult> bitmap_results_out;
+  std::vector<favicon_base::FaviconRawBitmapResult> bitmap_results_out;
   EXPECT_FALSE(backend_->GetFaviconsFromDB(page_url,
                                            favicon_base::FAVICON,
                                            kSmallSize.width(),
                                            GetScaleFactors1x2x(),
                                            &bitmap_results_out));
   EXPECT_TRUE(bitmap_results_out.empty());
 }
 
 // Test that GetFaviconsFromDB() returns results for the bitmaps which most
 // closely match the passed in desired size and scale factors.
 TEST_F(HistoryBackendTest, GetFaviconsFromDBSelectClosestMatch) {
   const GURL page_url("http://www.google.com/");
   const GURL icon_url("http://www.google.com/icon1");
 
-  std::vector<favicon_base::FaviconBitmapData> favicon_bitmap_data;
-  GenerateFaviconBitmapData(icon_url, GetSizesTinySmallAndLarge(),
-                            &favicon_bitmap_data);
+  std::vector<favicon_base::FaviconRawBitmapData> favicon_bitmap_data;
+  GenerateFaviconRawBitmapData(
+      icon_url, GetSizesTinySmallAndLarge(), &favicon_bitmap_data);
 
   backend_->SetFavicons(page_url, favicon_base::FAVICON, favicon_bitmap_data);
 
-  std::vector<favicon_base::FaviconBitmapResult> bitmap_results_out;
+  std::vector<favicon_base::FaviconRawBitmapResult> bitmap_results_out;
   EXPECT_TRUE(backend_->GetFaviconsFromDB(page_url,
                                           favicon_base::FAVICON,
                                           kSmallSize.width(),
                                           GetScaleFactors1x2x(),
                                           &bitmap_results_out));
 
   // The bitmap data for the small and large bitmaps should be returned as their
   // sizes match exactly.
   EXPECT_EQ(2u, bitmap_results_out.size());
   // No required order for results.
   if (bitmap_results_out[0].pixel_size == kLargeSize) {
-    favicon_base::FaviconBitmapResult tmp_result = bitmap_results_out[0];
+    favicon_base::FaviconRawBitmapResult tmp_result = bitmap_results_out[0];
     bitmap_results_out[0] = bitmap_results_out[1];
     bitmap_results_out[1] = tmp_result;
   }
 
   EXPECT_FALSE(bitmap_results_out[0].expired);
   EXPECT_TRUE(BitmapDataEqual('b', bitmap_results_out[0].bitmap_data));
   EXPECT_EQ(kSmallSize, bitmap_results_out[0].pixel_size);
   EXPECT_EQ(icon_url, bitmap_results_out[0].icon_url);
   EXPECT_EQ(favicon_base::FAVICON, bitmap_results_out[0].icon_type);
 
   EXPECT_FALSE(bitmap_results_out[1].expired);
   EXPECT_TRUE(BitmapDataEqual('c', bitmap_results_out[1].bitmap_data));
   EXPECT_EQ(kLargeSize, bitmap_results_out[1].pixel_size);
   EXPECT_EQ(icon_url, bitmap_results_out[1].icon_url);
   EXPECT_EQ(favicon_base::FAVICON, bitmap_results_out[1].icon_type);
 }
 
 // Test that GetFaviconsFromDB() returns results from the icon URL whose
 // bitmaps most closely match the passed in desired size and scale factors.
 TEST_F(HistoryBackendTest, GetFaviconsFromDBSingleIconURL) {
   const GURL page_url("http://www.google.com/");
 
   const GURL icon_url1("http://www.google.com/icon1");
   const GURL icon_url2("http://www.google.com/icon2");
 
-  std::vector<favicon_base::FaviconBitmapData> favicon_bitmap_data;
-  GenerateFaviconBitmapData(icon_url1, GetSizesSmall(), icon_url2,
-                            GetSizesLarge(), &favicon_bitmap_data);
+  std::vector<favicon_base::FaviconRawBitmapData> favicon_bitmap_data;
+  GenerateFaviconRawBitmapData(icon_url1,
+                               GetSizesSmall(),
+                               icon_url2,
+                               GetSizesLarge(),
+                               &favicon_bitmap_data);
 
   backend_->SetFavicons(page_url, favicon_base::FAVICON, favicon_bitmap_data);
 
-  std::vector<favicon_base::FaviconBitmapResult> bitmap_results_out;
+  std::vector<favicon_base::FaviconRawBitmapResult> bitmap_results_out;
   EXPECT_TRUE(backend_->GetFaviconsFromDB(page_url,
                                           favicon_base::FAVICON,
                                           kSmallSize.width(),
                                           GetScaleFactors1x2x(),
                                           &bitmap_results_out));
 
   // The results should have results for the icon URL with the large bitmap as
   // downscaling is preferred to upscaling.
   EXPECT_EQ(1u, bitmap_results_out.size());
   EXPECT_EQ(kLargeSize, bitmap_results_out[0].pixel_size);
   EXPECT_EQ(icon_url2, bitmap_results_out[0].icon_url);
 }
 
 // Test the results of GetFaviconsFromDB() when called with different
 // |icon_types|.
 TEST_F(HistoryBackendTest, GetFaviconsFromDBIconType) {
   const GURL page_url("http://www.google.com/");
   const GURL icon_url1("http://www.google.com/icon1.png");
   const GURL icon_url2("http://www.google.com/icon2.png");
 
-  std::vector<favicon_base::FaviconBitmapData> favicon_bitmap_data;
-  GenerateFaviconBitmapData(icon_url1, GetSizesSmall(),  &favicon_bitmap_data);
+  std::vector<favicon_base::FaviconRawBitmapData> favicon_bitmap_data;
+  GenerateFaviconRawBitmapData(
+      icon_url1, GetSizesSmall(), &favicon_bitmap_data);
   backend_->SetFavicons(page_url, favicon_base::FAVICON, favicon_bitmap_data);
 
-  GenerateFaviconBitmapData(icon_url2, GetSizesSmall(), &favicon_bitmap_data);
+  GenerateFaviconRawBitmapData(
+      icon_url2, GetSizesSmall(), &favicon_bitmap_data);
   backend_->SetFavicons(
       page_url, favicon_base::TOUCH_ICON, favicon_bitmap_data);
 
-  std::vector<favicon_base::FaviconBitmapResult> bitmap_results_out;
+  std::vector<favicon_base::FaviconRawBitmapResult> bitmap_results_out;
   EXPECT_TRUE(backend_->GetFaviconsFromDB(page_url,
                                           favicon_base::FAVICON,
                                           kSmallSize.width(),
                                           GetScaleFactors1x2x(),
                                           &bitmap_results_out));
 
   EXPECT_EQ(1u, bitmap_results_out.size());
   EXPECT_EQ(favicon_base::FAVICON, bitmap_results_out[0].icon_type);
   EXPECT_EQ(icon_url1, bitmap_results_out[0].icon_url);
 
@@ skipping 18 matching lines @@
   std::vector<unsigned char> data;
   data.push_back('a');
   scoped_refptr<base::RefCountedBytes> bitmap_data(
       base::RefCountedBytes::TakeVector(&data));
   base::Time last_updated = base::Time::FromTimeT(0);
   favicon_base::FaviconID icon_id = backend_->thumbnail_db_->AddFavicon(
       icon_url, favicon_base::FAVICON, bitmap_data, last_updated, kSmallSize);
   EXPECT_NE(0, icon_id);
   EXPECT_NE(0, backend_->thumbnail_db_->AddIconMapping(page_url, icon_id));
 
-  std::vector<favicon_base::FaviconBitmapResult> bitmap_results_out;
+  std::vector<favicon_base::FaviconRawBitmapResult> bitmap_results_out;
   EXPECT_TRUE(backend_->GetFaviconsFromDB(page_url,
                                           favicon_base::FAVICON,
                                           kSmallSize.width(),
                                           GetScaleFactors1x2x(),
                                           &bitmap_results_out));
 
   EXPECT_EQ(1u, bitmap_results_out.size());
   EXPECT_TRUE(bitmap_results_out[0].expired);
 }
 
 // Check that UpdateFaviconMappingsAndFetch() call back to the UI when there is
 // no valid thumbnail database.
 TEST_F(HistoryBackendTest, UpdateFaviconMappingsAndFetchNoDB) {
   // Make the thumbnail database invalid.
   backend_->thumbnail_db_.reset();
 
-  std::vector<favicon_base::FaviconBitmapResult> bitmap_results;
+  std::vector<favicon_base::FaviconRawBitmapResult> bitmap_results;
 
   backend_->UpdateFaviconMappingsAndFetch(GURL(),
                                           std::vector<GURL>(),
                                           favicon_base::FAVICON,
                                           kSmallSize.width(),
                                           GetScaleFactors1x2x(),
                                           &bitmap_results);
 
   EXPECT_TRUE(bitmap_results.empty());
 }
 
 TEST_F(HistoryBackendTest, CloneFaviconIsRestrictedToSameDomain) {
   const GURL url("http://www.google.com/");
   const GURL same_domain_url("http://www.google.com/subdir/index.html");
   const GURL foreign_domain_url("http://www.not-google.com/");
   const GURL icon_url("http://www.google.com/icon.png");
 
   // Add a favicon
-  std::vector<favicon_base::FaviconBitmapData> favicon_bitmap_data;
-  GenerateFaviconBitmapData(icon_url, GetSizesSmall(),  &favicon_bitmap_data);
+  std::vector<favicon_base::FaviconRawBitmapData> favicon_bitmap_data;
+  GenerateFaviconRawBitmapData(icon_url, GetSizesSmall(), &favicon_bitmap_data);
   backend_->SetFavicons(url, favicon_base::FAVICON, favicon_bitmap_data);
   EXPECT_TRUE(backend_->thumbnail_db_->GetIconMappingsForPageURL(
       url, favicon_base::FAVICON, NULL));
 
   // Validate starting state.
-  std::vector<favicon_base::FaviconBitmapResult> bitmap_results_out;
+  std::vector<favicon_base::FaviconRawBitmapResult> bitmap_results_out;
   EXPECT_TRUE(backend_->GetFaviconsFromDB(url,
                                           favicon_base::FAVICON,
                                           kSmallSize.width(),
                                           GetScaleFactors1x2x(),
                                           &bitmap_results_out));
   EXPECT_FALSE(backend_->GetFaviconsFromDB(same_domain_url,
                                            favicon_base::FAVICON,
                                            kSmallSize.width(),
                                            GetScaleFactors1x2x(),
                                            &bitmap_results_out));
@@ skipping 758 matching lines @@
   // Verify that the second term is no longer returned as result, and also check
   // at the low level that it is gone for good. The term corresponding to the
   // first URLRow should not be affected.
   EXPECT_EQ(1u, GetNumberOfMatchingSearchTerms(kTestKeywordId, term1));
   EXPECT_EQ(0u, GetNumberOfMatchingSearchTerms(kTestKeywordId, term2));
   EXPECT_TRUE(mem_backend_->db()->GetKeywordSearchTermRow(row1.id(), NULL));
   EXPECT_FALSE(mem_backend_->db()->GetKeywordSearchTermRow(row2.id(), NULL));
 }
 
 }  // namespace history